report.html

cupy/testing/_helper.py:1175: in test_func
impl(self, *args, **kw)
cupy/testing/_helper.py:825: in test_func
impl(self, *args, **kw)
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:648: in check_func
_array.assert_array_equal(x, y, err_msg, verbose, strides_check)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

x = array([0, 1]), y = array([0, 1]), err_msg = '', verbose = True
strides_check = True

def assert_array_equal(x, y, err_msg='', verbose=True, strides_check=False):
"""Raises an AssertionError if two array_like objects are not equal.

Args:
x(numpy.ndarray or cupy.ndarray): The actual object to check.
y(numpy.ndarray or cupy.ndarray): The desired, expected object.
strides_check(bool): If ``True``, consistency of strides is also
checked.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting values
are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_array_equal`
"""
> numpy.testing.assert_array_equal(
cupy.asnumpy(x), cupy.asnumpy(y), err_msg=err_msg,
verbose=verbose)
E AssertionError:
E Arrays are not equal
E
E Mismatched elements: 1 / 2 (50%)
E Max absolute difference: 4575657221408423936
E Max relative difference: 0.
E x: array([4575657221408423936, 1])
E y: array([0, 1])

cupy/testing/_array.py:91: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.int64'> order is C

self = <cupy_tests.functional_tests.test_vectorize.TestVectorizeStmts testMethod=test_return_tuple>
xp = <module 'cupy' from '/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.43REkaLqLV/cupy/cupy/__init__.py'>

@testing.numpy_cupy_array_equal()
def test_return_tuple(self, xp):
def func_tuple(x, y):
return x + y, x / y

f = xp.vectorize(func_tuple)
x = xp.array([0, 1, 2, 3, 4])
y = xp.array([5, 6, 7, 8, 9])
> return f(x, y)

tests/cupy_tests/functional_tests/test_vectorize.py:501:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/_functional/vectorize.py:97: in __call__
return kern(*args)
cupy/core/_kernel.pyx:840: in cupy.core._kernel.ElementwiseKernel.__call__
kern = self._get_elementwise_kernel(dev_id, arginfos, type_map)
cupy/core/_kernel.pyx:865: in cupy.core._kernel.ElementwiseKernel._get_elementwise_kernel
kern = _get_elementwise_kernel(
cupy/_util.pyx:59: in cupy._util.memoize.decorator.ret
result = f(*args, **kwargs)
cupy/core/_kernel.pyx:652: in cupy.core._kernel._get_elementwise_kernel
return _get_simple_elementwise_kernel(
cupy/core/_kernel.pyx:38: in cupy.core._kernel._get_simple_elementwise_kernel
cpdef function.Function _get_simple_elementwise_kernel(
cupy/core/_kernel.pyx:61: in cupy.core._kernel._get_simple_elementwise_kernel
module = compile_with_cache(module_code, options)
cupy/core/core.pyx:2021: in cupy.core.core.compile_with_cache
return cuda.compile_with_cache(
cupy/cuda/compiler.py:428: in compile_with_cache
return _compile_with_cache_hip(
cupy/cuda/compiler.py:811: in _compile_with_cache_hip
binary, mapping = compile_using_nvrtc(
cupy/cuda/compiler.py:271: in compile_using_nvrtc
return _compile(source, options, cu_path,
cupy/cuda/compiler.py:255: in _compile
ptx, mapping = prog.compile(options, log_stream)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <cupy.cuda.compiler._NVRTCProgram object at 0x7f9dea177340>
options = ('-I/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.43REkaLqLV/cupy/cupy/core/include', '-I/opt/rocm/include')
log_stream = None

def compile(self, options=(), log_stream=None):
try:
if self.name_expressions:
for ker in self.name_expressions:
nvrtc.addAddNameExpression(self.ptr, ker)
nvrtc.compileProgram(self.ptr, options)
mapping = None
if self.name_expressions:
mapping = {}
for ker in self.name_expressions:
mapping[ker] = nvrtc.getLoweredName(self.ptr, ker)
if log_stream is not None:
log_stream.write(nvrtc.getProgramLog(self.ptr))
# TODO(leofang): use getCUBIN() for _cuda_version >= 11010?
return nvrtc.getPTX(self.ptr), mapping
except nvrtc.NVRTCError:
log = nvrtc.getProgramLog(self.ptr)
> raise CompileException(log, self.src, self.name, options,
'nvrtc' if not runtime.is_hip else 'hiprtc')
E AssertionError: Only cupy raises error
E
E Traceback (most recent call last):
E File "/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.43REkaLqLV/cupy/cupy/cuda/compiler.py", line 623, in compile
E nvrtc.compileProgram(self.ptr, options)
E File "cupy_backends/cuda/libs/nvrtc.pyx", line 133, in cupy_backends.cuda.libs.nvrtc.compileProgram
E cpdef compileProgram(intptr_t prog, options):
E File "cupy_backends/cuda/libs/nvrtc.pyx", line 145, in cupy_backends.cuda.libs.nvrtc.compileProgram
E check_status(status)
E File "cupy_backends/cuda/libs/nvrtc.pyx", line 64, in cupy_backends.cuda.libs.nvrtc.check_status
E raise NVRTCError(status)
E cupy_backends.cuda.libs.nvrtc.NVRTCError: HIPRTC_ERROR_COMPILATION (6)
E
E During handling of the above exception, another exception occurred:
E
E Traceback (most recent call last):
E File "/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.43REkaLqLV/cupy/cupy/testing/_helper.py", line 47, in _call_func
E result = impl(self, *args, **kw)
E File "/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.43REkaLqLV/cupy/tests/cupy_tests/functional_tests/test_vectorize.py", line 501, in test_return_tuple
E return f(x, y)
E File "/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.43REkaLqLV/cupy/cupy/_functional/vectorize.py", line 97, in __call__
E return kern(*args)
E File "cupy/core/_kernel.pyx", line 840, in cupy.core._kernel.ElementwiseKernel.__call__
E kern = self._get_elementwise_kernel(dev_id, arginfos, type_map)
E File "cupy/core/_kernel.pyx", line 865, in cupy.core._kernel.ElementwiseKernel._get_elementwise_kernel
E kern = _get_elementwise_kernel(
E File "cupy/_util.pyx", line 59, in cupy._util.memoize.decorator.ret
E result = f(*args, **kwargs)
E File "cupy/core/_kernel.pyx", line 652, in cupy.core._kernel._get_elementwise_kernel
E return _get_simple_elementwise_kernel(
E File "cupy/core/_kernel.pyx", line 38, in cupy.core._kernel._get_simple_elementwise_kernel
E cpdef function.Function _get_simple_elementwise_kernel(
E File "cupy/core/_kernel.pyx", line 61, in cupy.core._kernel._get_simple_elementwise_kernel
E module = compile_with_cache(module_code, options)
E File "cupy/core/core.pyx", line 2021, in cupy.core.core.compile_with_cache
E return cuda.compile_with_cache(
E File "/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.43REkaLqLV/cupy/cupy/cuda/compiler.py", line 428, in compile_with_cache
E return _compile_with_cache_hip(
E File "/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.43REkaLqLV/cupy/cupy/cuda/compiler.py", line 811, in _compile_with_cache_hip
E binary, mapping = compile_using_nvrtc(
E File "/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.43REkaLqLV/cupy/cupy/cuda/compiler.py", line 271, in compile_using_nvrtc
E return _compile(source, options, cu_path,
E File "/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.43REkaLqLV/cupy/cupy/cuda/compiler.py", line 255, in _compile
E ptx, mapping = prog.compile(options, log_stream)
E File "/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.43REkaLqLV/cupy/cupy/cuda/compiler.py", line 635, in compile
E raise CompileException(log, self.src, self.name, options,
E cupy.cuda.compiler.CompileException: /tmp/comgr-2e9a76/input/CompileSource:5368:12: error: no template named 'tuple' in namespace 'thrust'; did you mean 'std::tuple'?
E __device__ thrust::tuple<long long, double> func_tuple(long long x, long long y) {
E ^~~~~~~~~~~~~
E std::tuple
E /usr/lib/gcc/x86_64-linux-gnu/7.5.0/../../../../include/c++/7.5.0/tuple:556:11: note: 'std::tuple' declared here
E class tuple : public _Tuple_impl<0, _Elements...>
E ^
E /tmp/comgr-2e9a76/input/CompileSource:5369:10: error: no member named 'make_tuple' in namespace 'thrust'; did you mean 'std::make_tuple'?
E return thrust::make_tuple((x + y), ((double)x / (double)y));
E ^~~~~~~~~~~~~~~~~~
E std::make_tuple
E /usr/lib/gcc/x86_64-linux-gnu/7.5.0/../../../../include/c++/7.5.0/tuple:1448:5: note: 'std::make_tuple' declared here
E make_tuple(_Elements&&... __args)
E ^
E /tmp/comgr-2e9a76/input/CompileSource:5379:9: error: no member named 'tie' in namespace 'thrust'
E thrust::tie(out0, out1) = func_tuple(in0, in1);
E ~~~~~~~~^
E 3 errors generated when compiling for gfx906.
E Error: Failed to compile opencl source (from CL or HIP source to LLVM IR).

cupy/cuda/compiler.py:635: AssertionError

self = <cupy_tests.functional_tests.test_vectorize.TestVectorizeStmts testMethod=test_tuple>
xp = <module 'cupy' from '/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.43REkaLqLV/cupy/cupy/__init__.py'>

@testing.numpy_cupy_array_equal()
def test_tuple(self, xp):
def func_tuple(x, y):
x, y = y, x
z = x, y
a, b = z
return a * a + b

f = xp.vectorize(func_tuple)
x = xp.array([0, 1, 2, 3, 4])
y = xp.array([5, 6, 7, 8, 9])
> return f(x, y)

tests/cupy_tests/functional_tests/test_vectorize.py:491:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/_functional/vectorize.py:97: in __call__
return kern(*args)
cupy/core/_kernel.pyx:840: in cupy.core._kernel.ElementwiseKernel.__call__
kern = self._get_elementwise_kernel(dev_id, arginfos, type_map)
cupy/core/_kernel.pyx:865: in cupy.core._kernel.ElementwiseKernel._get_elementwise_kernel
kern = _get_elementwise_kernel(
cupy/_util.pyx:59: in cupy._util.memoize.decorator.ret
result = f(*args, **kwargs)
cupy/core/_kernel.pyx:652: in cupy.core._kernel._get_elementwise_kernel
return _get_simple_elementwise_kernel(
cupy/core/_kernel.pyx:38: in cupy.core._kernel._get_simple_elementwise_kernel
cpdef function.Function _get_simple_elementwise_kernel(
cupy/core/_kernel.pyx:61: in cupy.core._kernel._get_simple_elementwise_kernel
module = compile_with_cache(module_code, options)
cupy/core/core.pyx:2021: in cupy.core.core.compile_with_cache
return cuda.compile_with_cache(
cupy/cuda/compiler.py:428: in compile_with_cache
return _compile_with_cache_hip(
cupy/cuda/compiler.py:811: in _compile_with_cache_hip
binary, mapping = compile_using_nvrtc(
cupy/cuda/compiler.py:271: in compile_using_nvrtc
return _compile(source, options, cu_path,
cupy/cuda/compiler.py:255: in _compile
ptx, mapping = prog.compile(options, log_stream)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <cupy.cuda.compiler._NVRTCProgram object at 0x7f9f63295ca0>
options = ('-I/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.43REkaLqLV/cupy/cupy/core/include', '-I/opt/rocm/include')
log_stream = None

def compile(self, options=(), log_stream=None):
try:
if self.name_expressions:
for ker in self.name_expressions:
nvrtc.addAddNameExpression(self.ptr, ker)
nvrtc.compileProgram(self.ptr, options)
mapping = None
if self.name_expressions:
mapping = {}
for ker in self.name_expressions:
mapping[ker] = nvrtc.getLoweredName(self.ptr, ker)
if log_stream is not None:
log_stream.write(nvrtc.getProgramLog(self.ptr))
# TODO(leofang): use getCUBIN() for _cuda_version >= 11010?
return nvrtc.getPTX(self.ptr), mapping
except nvrtc.NVRTCError:
log = nvrtc.getProgramLog(self.ptr)
> raise CompileException(log, self.src, self.name, options,
'nvrtc' if not runtime.is_hip else 'hiprtc')
E AssertionError: Only cupy raises error
E
E Traceback (most recent call last):
E File "/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.43REkaLqLV/cupy/cupy/cuda/compiler.py", line 623, in compile
E nvrtc.compileProgram(self.ptr, options)
E File "cupy_backends/cuda/libs/nvrtc.pyx", line 133, in cupy_backends.cuda.libs.nvrtc.compileProgram
E cpdef compileProgram(intptr_t prog, options):
E File "cupy_backends/cuda/libs/nvrtc.pyx", line 145, in cupy_backends.cuda.libs.nvrtc.compileProgram
E check_status(status)
E File "cupy_backends/cuda/libs/nvrtc.pyx", line 64, in cupy_backends.cuda.libs.nvrtc.check_status
E raise NVRTCError(status)
E cupy_backends.cuda.libs.nvrtc.NVRTCError: HIPRTC_ERROR_COMPILATION (6)
E
E During handling of the above exception, another exception occurred:
E
E Traceback (most recent call last):
E File "/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.43REkaLqLV/cupy/cupy/testing/_helper.py", line 47, in _call_func
E result = impl(self, *args, **kw)
E File "/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.43REkaLqLV/cupy/tests/cupy_tests/functional_tests/test_vectorize.py", line 491, in test_tuple
E return f(x, y)
E File "/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.43REkaLqLV/cupy/cupy/_functional/vectorize.py", line 97, in __call__
E return kern(*args)
E File "cupy/core/_kernel.pyx", line 840, in cupy.core._kernel.ElementwiseKernel.__call__
E kern = self._get_elementwise_kernel(dev_id, arginfos, type_map)
E File "cupy/core/_kernel.pyx", line 865, in cupy.core._kernel.ElementwiseKernel._get_elementwise_kernel
E kern = _get_elementwise_kernel(
E File "cupy/_util.pyx", line 59, in cupy._util.memoize.decorator.ret
E result = f(*args, **kwargs)
E File "cupy/core/_kernel.pyx", line 652, in cupy.core._kernel._get_elementwise_kernel
E return _get_simple_elementwise_kernel(
E File "cupy/core/_kernel.pyx", line 38, in cupy.core._kernel._get_simple_elementwise_kernel
E cpdef function.Function _get_simple_elementwise_kernel(
E File "cupy/core/_kernel.pyx", line 61, in cupy.core._kernel._get_simple_elementwise_kernel
E module = compile_with_cache(module_code, options)
E File "cupy/core/core.pyx", line 2021, in cupy.core.core.compile_with_cache
E return cuda.compile_with_cache(
E File "/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.43REkaLqLV/cupy/cupy/cuda/compiler.py", line 428, in compile_with_cache
E return _compile_with_cache_hip(
E File "/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.43REkaLqLV/cupy/cupy/cuda/compiler.py", line 811, in _compile_with_cache_hip
E binary, mapping = compile_using_nvrtc(
E File "/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.43REkaLqLV/cupy/cupy/cuda/compiler.py", line 271, in compile_using_nvrtc
E return _compile(source, options, cu_path,
E File "/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.43REkaLqLV/cupy/cupy/cuda/compiler.py", line 255, in _compile
E ptx, mapping = prog.compile(options, log_stream)
E File "/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.43REkaLqLV/cupy/cupy/cuda/compiler.py", line 635, in compile
E raise CompileException(log, self.src, self.name, options,
E cupy.cuda.compiler.CompileException: /tmp/comgr-909ce0/input/CompileSource:5369:3: error: no template named 'tuple' in namespace 'thrust'; did you mean 'std::tuple'?
E thrust::tuple<long long, long long> z;
E ^~~~~~~~~~~~~
E std::tuple
E /usr/lib/gcc/x86_64-linux-gnu/7.5.0/../../../../include/c++/7.5.0/tuple:556:11: note: 'std::tuple' declared here
E class tuple : public _Tuple_impl<0, _Elements...>
E ^
E /tmp/comgr-909ce0/input/CompileSource:5372:11: error: no member named 'tie' in namespace 'thrust'
E thrust::tie(x, y) = thrust::make_tuple(y, x);
E ~~~~~~~~^
E /tmp/comgr-909ce0/input/CompileSource:5372:31: error: no member named 'make_tuple' in namespace 'thrust'
E thrust::tie(x, y) = thrust::make_tuple(y, x);
E ~~~~~~~~^
E /tmp/comgr-909ce0/input/CompileSource:5373:15: error: no member named 'make_tuple' in namespace 'thrust'
E z = thrust::make_tuple(x, y);
E ~~~~~~~~^
E /tmp/comgr-909ce0/input/CompileSource:5374:11: error: no member named 'tie' in namespace 'thrust'
E thrust::tie(a, b) = z;
E ~~~~~~~~^
E 5 errors generated when compiling for gfx906.
E Error: Failed to compile opencl source (from CL or HIP source to LLVM IR).

cupy/cuda/compiler.py:635: AssertionError

cupy/testing/_helper.py:825: in test_func
impl(self, *args, **kw)
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:648: in check_func
_array.assert_array_equal(x, y, err_msg, verbose, strides_check)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

x = array([[0, 1, 2],
[3, 4, 5]], dtype=int8)
y = array([[0, 1, 2],
[3, 4, 5]], dtype=int8), err_msg = ''
verbose = True, strides_check = False

def assert_array_equal(x, y, err_msg='', verbose=True, strides_check=False):
"""Raises an AssertionError if two array_like objects are not equal.

Args:
x(numpy.ndarray or cupy.ndarray): The actual object to check.
y(numpy.ndarray or cupy.ndarray): The desired, expected object.
strides_check(bool): If ``True``, consistency of strides is also
checked.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting values
are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_array_equal`
"""
> numpy.testing.assert_array_equal(
cupy.asnumpy(x), cupy.asnumpy(y), err_msg=err_msg,
verbose=verbose)
E AssertionError:
E Arrays are not equal
E
E Mismatched elements: 1 / 6 (16.7%)
E Max absolute difference: 1
E Max relative difference: 1.
E x: array([[0, 0, 2],
E [3, 4, 5]], dtype=int8)
E y: array([[0, 1, 2],
E [3, 4, 5]], dtype=int8)

cupy/testing/_array.py:91: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.int8'>

self = <<cupyx_tests.scipy_tests.linalg_tests.test_decomp_lu.TestLUSolve_param_0_{shapes=((4, 4), (4,)), trans=0} testMethod=test_lu_solve> parameter: {'shapes': ((4, 4), (4,)), 'trans': 0}>
xp = <module 'cupy' from '/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.43REkaLqLV/cupy/cupy/__init__.py'>
scp = <module 'cupyx.scipy' from '/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.43REkaLqLV/cupy/cupyx/scipy/__init__.py'>
dtype = <class 'numpy.complex64'>

@testing.for_dtypes('fdFD')
@testing.numpy_cupy_allclose(atol=1e-5, scipy_name='scp')
def test_lu_solve(self, xp, scp, dtype):
a_shape, b_shape = self.shapes
A = testing.shaped_random(a_shape, xp, dtype=dtype)
b = testing.shaped_random(b_shape, xp, dtype=dtype)
lu = scp.linalg.lu_factor(A)
> return scp.linalg.lu_solve(lu, b, trans=self.trans)

tests/cupyx_tests/scipy_tests/linalg_tests/test_decomp_lu.py:133:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

lu_and_piv = (array([[ 4.236548 +9.786183j , 6.458941 +7.9915857j ,
4.375872 +4.614794j , 8.91773 +7.8052... -0.6066229 -0.41192332j, -10.515662 +8.309107j ]],
dtype=complex64), array([1, 1, 2, 3], dtype=int32))
b = array([ 0.33598816-0.05543445j, 0.16491814+0.38266957j,
-0.22301029-0.13307956j, 0.54701537-0.34111553j], dtype=complex64)
trans = 0, overwrite_b = False, check_finite = True

def lu_solve(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True):
"""Solve an equation system, ``a * x = b``, given the LU factorization of ``a``

Args:
lu_and_piv (tuple): LU factorization of matrix ``a`` (``(M, M)``)
together with pivot indices.
b (cupy.ndarray): The matrix with dimension ``(M,)`` or
``(M, N)``.
trans ({0, 1, 2}): Type of system to solve:

======== =========
trans system
======== =========
0 a x = b
1 a^T x = b
2 a^H x = b
======== =========
overwrite_b (bool): Allow overwriting data in b (may enhance
performance)
check_finite (bool): Whether to check that the input matrices contain
only finite numbers. Disabling may give a performance gain, but may
result in problems (crashes, non-termination) if the inputs do
contain infinities or NaNs.

Returns:
cupy.ndarray:
The matrix with dimension ``(M,)`` or ``(M, N)``.

.. seealso:: :func:`scipy.linalg.lu_solve`
"""

(lu, ipiv) = lu_and_piv

_util._assert_cupy_array(lu)
_util._assert_rank2(lu)
_util._assert_nd_squareness(lu)

m = lu.shape[0]
if m != b.shape[0]:
raise ValueError('incompatible dimensions.')

dtype = lu.dtype
if dtype.char == 'f':
getrs = cusolver.sgetrs
elif dtype.char == 'd':
getrs = cusolver.dgetrs
elif dtype.char == 'F':
getrs = cusolver.cgetrs
elif dtype.char == 'D':
getrs = cusolver.zgetrs
else:
msg = 'Only float32, float64, complex64 and complex128 are supported.'
raise NotImplementedError(msg)

if trans == 0:
trans = cublas.CUBLAS_OP_N
elif trans == 1:
trans = cublas.CUBLAS_OP_T
elif trans == 2:
trans = cublas.CUBLAS_OP_C
else:
raise ValueError('unknown trans')

lu = lu.astype(dtype, order='F', copy=False)
ipiv = ipiv.astype(ipiv.dtype, order='F', copy=True)
# cuSolver uses 1-origin while SciPy uses 0-origin
ipiv += 1
b = b.astype(dtype, order='F', copy=(not overwrite_b))

if check_finite:
if lu.dtype.kind == 'f' and not cupy.isfinite(lu).all():
raise ValueError(
'array must not contain infs or NaNs.\n'
'Note that when a singular matrix is given, unlike '
'scipy.linalg.lu_factor, cupyx.scipy.linalg.lu_factor '
'returns an array containing NaN.')
if b.dtype.kind == 'f' and not cupy.isfinite(b).all():
raise ValueError(
'array must not contain infs or NaNs')

n = 1 if b.ndim == 1 else b.shape[1]
cusolver_handle = device.get_cusolver_handle()
dev_info = cupy.empty(1, dtype=numpy.int32)

# solve for the inverse
getrs(cusolver_handle,
trans,
m, n, lu.data.ptr, m, ipiv.data.ptr, b.data.ptr,
m, dev_info.data.ptr)

if dev_info[0] < 0:
> raise ValueError('illegal value in %d-th argument of '
'internal getrs (lu_solve)' % -dev_info[0])
E AssertionError: Only cupy raises error
E
E Traceback (most recent call last):
E File "/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.43REkaLqLV/cupy/cupy/testing/_helper.py", line 47, in _call_func
E result = impl(self, *args, **kw)
E File "/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.43REkaLqLV/cupy/tests/cupyx_tests/scipy_tests/linalg_tests/test_decomp_lu.py", line 133, in test_lu_solve
E return scp.linalg.lu_solve(lu, b, trans=self.trans)
E File "/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.43REkaLqLV/cupy/cupyx/scipy/linalg/decomp_lu.py", line 344, in lu_solve
E raise ValueError('illegal value in %d-th argument of '
E ValueError: illegal value in 1904661248-th argument of internal getrs (lu_solve)

cupyx/scipy/linalg/decomp_lu.py:344: AssertionError
------------------------------Captured stdout call------------------------------
dtype is F

self = <<cupyx_tests.scipy_tests.linalg_tests.test_decomp_lu.TestLUSolve_param_3_{shapes=((5, 5), (5, 2)), trans=0} testMethod=test_lu_solve> parameter: {'shapes': ((5, 5), (5, 2)), 'trans': 0}>
xp = <module 'cupy' from '/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.43REkaLqLV/cupy/cupy/__init__.py'>
scp = <module 'cupyx.scipy' from '/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.43REkaLqLV/cupy/cupyx/scipy/__init__.py'>
dtype = <class 'numpy.complex128'>

@testing.for_dtypes('fdFD')
@testing.numpy_cupy_allclose(atol=1e-5, scipy_name='scp')
def test_lu_solve(self, xp, scp, dtype):
a_shape, b_shape = self.shapes
A = testing.shaped_random(a_shape, xp, dtype=dtype)
b = testing.shaped_random(b_shape, xp, dtype=dtype)
lu = scp.linalg.lu_factor(A)
> return scp.linalg.lu_solve(lu, b, trans=self.trans)

tests/cupyx_tests/scipy_tests/linalg_tests/test_decomp_lu.py:133:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

lu_and_piv = (array([[ 9.78618342 +6.7063787j , 7.99158564 +2.10382561j,
4.61479362 +1.28926298j, 7.80529176 +3.15428351...09693 +0.11253535j, -0.19530724 +0.3829403j ,
1.48165651 +3.00519867j]]), array([4, 1, 4, 3, 4], dtype=int32))
b = array([[ 2.62387605-0.26982085j, 2.2387386 +2.17849744j],
[-1.24752213-1.21928963j, 1.06884568-2.83274516j],
...
[-0.94068427+3.72322175j, -5.04078357+2.5571273j ],
[-3.22951911-0.30141784j, -2.28920225-3.23327497j]])
trans = 0, overwrite_b = False, check_finite = True

def lu_solve(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True):
"""Solve an equation system, ``a * x = b``, given the LU factorization of ``a``

Args:
lu_and_piv (tuple): LU factorization of matrix ``a`` (``(M, M)``)
together with pivot indices.
b (cupy.ndarray): The matrix with dimension ``(M,)`` or
``(M, N)``.
trans ({0, 1, 2}): Type of system to solve:

======== =========
trans system
======== =========
0 a x = b
1 a^T x = b
2 a^H x = b
======== =========
overwrite_b (bool): Allow overwriting data in b (may enhance
performance)
check_finite (bool): Whether to check that the input matrices contain
only finite numbers. Disabling may give a performance gain, but may
result in problems (crashes, non-termination) if the inputs do
contain infinities or NaNs.

Returns:
cupy.ndarray:
The matrix with dimension ``(M,)`` or ``(M, N)``.

.. seealso:: :func:`scipy.linalg.lu_solve`
"""

(lu, ipiv) = lu_and_piv

_util._assert_cupy_array(lu)
_util._assert_rank2(lu)
_util._assert_nd_squareness(lu)

m = lu.shape[0]
if m != b.shape[0]:
raise ValueError('incompatible dimensions.')

dtype = lu.dtype
if dtype.char == 'f':
getrs = cusolver.sgetrs
elif dtype.char == 'd':
getrs = cusolver.dgetrs
elif dtype.char == 'F':
getrs = cusolver.cgetrs
elif dtype.char == 'D':
getrs = cusolver.zgetrs
else:
msg = 'Only float32, float64, complex64 and complex128 are supported.'
raise NotImplementedError(msg)

if trans == 0:
trans = cublas.CUBLAS_OP_N
elif trans == 1:
trans = cublas.CUBLAS_OP_T
elif trans == 2:
trans = cublas.CUBLAS_OP_C
else:
raise ValueError('unknown trans')

lu = lu.astype(dtype, order='F', copy=False)
ipiv = ipiv.astype(ipiv.dtype, order='F', copy=True)
# cuSolver uses 1-origin while SciPy uses 0-origin
ipiv += 1
b = b.astype(dtype, order='F', copy=(not overwrite_b))

if check_finite:
if lu.dtype.kind == 'f' and not cupy.isfinite(lu).all():
raise ValueError(
'array must not contain infs or NaNs.\n'
'Note that when a singular matrix is given, unlike '
'scipy.linalg.lu_factor, cupyx.scipy.linalg.lu_factor '
'returns an array containing NaN.')
if b.dtype.kind == 'f' and not cupy.isfinite(b).all():
raise ValueError(
'array must not contain infs or NaNs')

n = 1 if b.ndim == 1 else b.shape[1]
cusolver_handle = device.get_cusolver_handle()
dev_info = cupy.empty(1, dtype=numpy.int32)

# solve for the inverse
getrs(cusolver_handle,
trans,
m, n, lu.data.ptr, m, ipiv.data.ptr, b.data.ptr,
m, dev_info.data.ptr)

if dev_info[0] < 0:
> raise ValueError('illegal value in %d-th argument of '
'internal getrs (lu_solve)' % -dev_info[0])
E AssertionError: Only cupy raises error
E
E Traceback (most recent call last):
E File "/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.43REkaLqLV/cupy/cupy/testing/_helper.py", line 47, in _call_func
E result = impl(self, *args, **kw)
E File "/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.43REkaLqLV/cupy/tests/cupyx_tests/scipy_tests/linalg_tests/test_decomp_lu.py", line 133, in test_lu_solve
E return scp.linalg.lu_solve(lu, b, trans=self.trans)
E File "/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.43REkaLqLV/cupy/cupyx/scipy/linalg/decomp_lu.py", line 344, in lu_solve
E raise ValueError('illegal value in %d-th argument of '
E ValueError: illegal value in 1573970959-th argument of internal getrs (lu_solve)

cupyx/scipy/linalg/decomp_lu.py:344: AssertionError
------------------------------Captured stdout call------------------------------
dtype is D

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_filters.TestGenericFilter object at 0x7f9ca796e310> parameter: {'filter'...ss 'numpy.uint8'>, 'ksize': 3, 'mode': 'mirror', 'shape': (4, 5), 'function': <function rms_pyfunc at 0x7f9db3c38940>}>
args = (), kw = {}
cupy_result = (array([[21, 31, 40, 31, 33],
[27, 29, 28, 20, 27],
[14, 25, 35, 34, 32],
[27, 26, 33, 25, 31]], dtype=uint8),)
cupy_error = None
numpy_result = (array([[28, 38, 48, 42, 45],
[32, 36, 44, 37, 44],
[18, 31, 45, 48, 55],
[22, 29, 41, 43, 54]], dtype=uint8),)
numpy_error = None
cupy_numpy_result_ndarrays = [(array([[21, 31, 40, 31, 33],
[27, 29, 28, 20, 27],
[14, 25, 35, 34, 32],
[27, 26, 33, 25, 31]],...38, 48, 42, 45],
[32, 36, 44, 37, 44],
[18, 31, 45, 48, 55],
[22, 29, 41, 43, 54]], dtype=uint8))]
cupy_r = array([[21, 31, 40, 31, 33],
[27, 29, 28, 20, 27],
[14, 25, 35, 34, 32],
[27, 26, 33, 25, 31]], dtype=uint8)
numpy_r = array([[28, 38, 48, 42, 45],
[32, 36, 44, 37, 44],
[18, 31, 45, 48, 55],
[22, 29, 41, 43, 54]], dtype=uint8)
skip = False

@_wraps_partial_xp(impl, name, sp_name, scipy_name)
def test_func(self, *args, **kw):
# Run cupy and numpy
(
cupy_result, cupy_error,
numpy_result, numpy_error) = (
_call_func_numpy_cupy(
self, impl, args, kw, name, sp_name, scipy_name))
assert cupy_result is not None or cupy_error is not None
assert numpy_result is not None or numpy_error is not None

# Check errors raised
if cupy_error or numpy_error:
_check_cupy_numpy_error(cupy_error,
numpy_error,
accept_error=accept_error)
return

# Check returned arrays

if not isinstance(cupy_result, (tuple, list)):
cupy_result = cupy_result,
if not isinstance(numpy_result, (tuple, list)):
numpy_result = numpy_result,

assert len(cupy_result) == len(numpy_result)

# Check types
cupy_numpy_result_ndarrays = [
_convert_output_to_ndarray(
cupy_r, numpy_r, sp_name, check_sparse_format)
for cupy_r, numpy_r in zip(cupy_result, numpy_result)]

# Check dtypes
if type_check:
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
if cupy_r.dtype != numpy_r.dtype:
raise AssertionError(
'''ndarrays of different dtypes are returned.
cupy: {}
numpy: {}'''.format(cupy_r.dtype, numpy_r.dtype))

# Check contiguities
if contiguous_check:
for cupy_r, numpy_r in zip(cupy_result, numpy_result):
if isinstance(numpy_r, numpy.ndarray):
if (numpy_r.flags.c_contiguous
and not cupy_r.flags.c_contiguous):
raise AssertionError(
'The state of c_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.c_contiguous,
numpy_r.flags.c_contiguous))
if (numpy_r.flags.f_contiguous
and not cupy_r.flags.f_contiguous):
raise AssertionError(
'The state of f_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.f_contiguous,
numpy_r.flags.f_contiguous))

# Check shapes
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
assert cupy_r.shape == numpy_r.shape

# Check item values
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
# Behavior of assigning a negative value to an unsigned integer
# variable is undefined.
# nVidia GPUs and Intel CPUs behave differently.
# To avoid this difference, we need to ignore dimensions whose
# values are negative.

skip = False
if (_contains_signed_and_unsigned(kw)
and cupy_r.dtype in _unsigned_dtypes):
mask = _make_positive_mask(
self, impl, args, kw, name, sp_name, scipy_name)
if cupy_r.shape == ():
skip = (mask == 0).all()
else:
cupy_r = cupy_r[mask].get()
numpy_r = numpy_r[mask]

if not skip:
> check_func(cupy_r, numpy_r)

cupy/testing/_helper.py:343:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[21, 31, 40, 31, 33],
[27, 29, 28, 20, 27],
[14, 25, 35, 34, 32],
[27, 26, 33, 25, 31]], dtype=uint8)
desired = array([[28, 38, 48, 42, 45],
[32, 36, 44, 37, 44],
[18, 31, 45, 48, 55],
[22, 29, 41, 43, 54]], dtype=uint8)
rtol = 1e-05, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-05, atol=1e-05
E
E Mismatched elements: 20 / 20 (100%)
E Max absolute difference: 253
E Max relative difference: 14.
E x: array([[21, 31, 40, 31, 33],
E [27, 29, 28, 20, 27],
E [14, 25, 35, 34, 32],
E [27, 26, 33, 25, 31]], dtype=uint8)
E y: array([[28, 38, 48, 42, 45],
E [32, 36, 44, 37, 44],
E [18, 31, 45, 48, 55],
E [22, 29, 41, 43, 54]], dtype=uint8)

cupy/testing/_array.py:24: AssertionError

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_filters.TestGenericFilter object at 0x7f9ca7982040> parameter: {'filter'...ss 'numpy.uint8'>, 'ksize': 4, 'mode': 'mirror', 'shape': (4, 5), 'function': <function rms_pyfunc at 0x7f9db3c38940>}>
args = (), kw = {}
cupy_result = (array([[28, 24, 32, 32, 39],
[ 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0]], dtype=uint8),)
cupy_error = None
numpy_result = (array([[34, 34, 44, 37, 47],
[34, 34, 44, 37, 47],
[29, 29, 39, 37, 46],
[27, 27, 41, 38, 52]], dtype=uint8),)
numpy_error = None
cupy_numpy_result_ndarrays = [(array([[28, 24, 32, 32, 39],
[ 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0]],...34, 44, 37, 47],
[34, 34, 44, 37, 47],
[29, 29, 39, 37, 46],
[27, 27, 41, 38, 52]], dtype=uint8))]
cupy_r = array([[28, 24, 32, 32, 39],
[ 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0]], dtype=uint8)
numpy_r = array([[34, 34, 44, 37, 47],
[34, 34, 44, 37, 47],
[29, 29, 39, 37, 46],
[27, 27, 41, 38, 52]], dtype=uint8)
skip = False

@_wraps_partial_xp(impl, name, sp_name, scipy_name)
def test_func(self, *args, **kw):
# Run cupy and numpy
(
cupy_result, cupy_error,
numpy_result, numpy_error) = (
_call_func_numpy_cupy(
self, impl, args, kw, name, sp_name, scipy_name))
assert cupy_result is not None or cupy_error is not None
assert numpy_result is not None or numpy_error is not None

# Check errors raised
if cupy_error or numpy_error:
_check_cupy_numpy_error(cupy_error,
numpy_error,
accept_error=accept_error)
return

# Check returned arrays

if not isinstance(cupy_result, (tuple, list)):
cupy_result = cupy_result,
if not isinstance(numpy_result, (tuple, list)):
numpy_result = numpy_result,

assert len(cupy_result) == len(numpy_result)

# Check types
cupy_numpy_result_ndarrays = [
_convert_output_to_ndarray(
cupy_r, numpy_r, sp_name, check_sparse_format)
for cupy_r, numpy_r in zip(cupy_result, numpy_result)]

# Check dtypes
if type_check:
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
if cupy_r.dtype != numpy_r.dtype:
raise AssertionError(
'''ndarrays of different dtypes are returned.
cupy: {}
numpy: {}'''.format(cupy_r.dtype, numpy_r.dtype))

# Check contiguities
if contiguous_check:
for cupy_r, numpy_r in zip(cupy_result, numpy_result):
if isinstance(numpy_r, numpy.ndarray):
if (numpy_r.flags.c_contiguous
and not cupy_r.flags.c_contiguous):
raise AssertionError(
'The state of c_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.c_contiguous,
numpy_r.flags.c_contiguous))
if (numpy_r.flags.f_contiguous
and not cupy_r.flags.f_contiguous):
raise AssertionError(
'The state of f_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.f_contiguous,
numpy_r.flags.f_contiguous))

# Check shapes
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
assert cupy_r.shape == numpy_r.shape

# Check item values
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
# Behavior of assigning a negative value to an unsigned integer
# variable is undefined.
# nVidia GPUs and Intel CPUs behave differently.
# To avoid this difference, we need to ignore dimensions whose
# values are negative.

skip = False
if (_contains_signed_and_unsigned(kw)
and cupy_r.dtype in _unsigned_dtypes):
mask = _make_positive_mask(
self, impl, args, kw, name, sp_name, scipy_name)
if cupy_r.shape == ():
skip = (mask == 0).all()
else:
cupy_r = cupy_r[mask].get()
numpy_r = numpy_r[mask]

if not skip:
> check_func(cupy_r, numpy_r)

cupy/testing/_helper.py:343:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[28, 24, 32, 32, 39],
[ 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0]], dtype=uint8)
desired = array([[34, 34, 44, 37, 47],
[34, 34, 44, 37, 47],
[29, 29, 39, 37, 46],
[27, 27, 41, 38, 52]], dtype=uint8)
rtol = 1e-05, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-05, atol=1e-05
E
E Mismatched elements: 20 / 20 (100%)
E Max absolute difference: 251
E Max relative difference: 8.48148148
E x: array([[28, 24, 32, 32, 39],
E [ 0, 0, 0, 0, 0],
E [ 0, 0, 0, 0, 0],
E [ 0, 0, 0, 0, 0]], dtype=uint8)
E y: array([[34, 34, 44, 37, 47],
E [34, 34, 44, 37, 47],
E [29, 29, 39, 37, 46],
E [27, 27, 41, 38, 52]], dtype=uint8)

cupy/testing/_array.py:24: AssertionError

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_filters.TestGenericFilter object at 0x7f9ca78f6eb0> parameter: {'filter'... 'numpy.float64'>, 'ksize': 3, 'mode': 'mirror', 'shape': (4, 5), 'function': <function rms_pyfunc at 0x7f9db3c38940>}>
args = (), kw = {}
cupy_result = (array([[30.36659675, 39.62975648, 53.45565341, 42.0701155 , 42.81412414],
[33.36838531, 37.73390254, 33.011765...2, 44.03386405, 43.67148673, 48.63067102],
[32.28830047, 30.15609296, 36.65741325, 35.73179981, 40.69098504]]),)
cupy_error = None
numpy_result = (array([[32.49418447, 44.26508328, 55.58324819, 50.90632842, 53.13241351],
[36.78467189, 42.32410703, 50.513759...4, 51.93015205, 56.78985728, 63.23111802],
[26.45539443, 35.1080233 , 46.86066347, 49.16227375, 60.05539763]]),)
numpy_error = None
cupy_numpy_result_ndarrays = [(array([[30.36659675, 39.62975648, 53.45565341, 42.0701155 , 42.81412414],
[33.36838531, 37.73390254, 33.01176...4, 51.93015205, 56.78985728, 63.23111802],
[26.45539443, 35.1080233 , 46.86066347, 49.16227375, 60.05539763]]))]
cupy_r = array([[30.36659675, 39.62975648, 53.45565341, 42.0701155 , 42.81412414],
[33.36838531, 37.73390254, 33.0117654...672, 44.03386405, 43.67148673, 48.63067102],
[32.28830047, 30.15609296, 36.65741325, 35.73179981, 40.69098504]])
numpy_r = array([[32.49418447, 44.26508328, 55.58324819, 50.90632842, 53.13241351],
[36.78467189, 42.32410703, 50.5137596...954, 51.93015205, 56.78985728, 63.23111802],
[26.45539443, 35.1080233 , 46.86066347, 49.16227375, 60.05539763]])
skip = False

@_wraps_partial_xp(impl, name, sp_name, scipy_name)
def test_func(self, *args, **kw):
# Run cupy and numpy
(
cupy_result, cupy_error,
numpy_result, numpy_error) = (
_call_func_numpy_cupy(
self, impl, args, kw, name, sp_name, scipy_name))
assert cupy_result is not None or cupy_error is not None
assert numpy_result is not None or numpy_error is not None

# Check errors raised
if cupy_error or numpy_error:
_check_cupy_numpy_error(cupy_error,
numpy_error,
accept_error=accept_error)
return

# Check returned arrays

if not isinstance(cupy_result, (tuple, list)):
cupy_result = cupy_result,
if not isinstance(numpy_result, (tuple, list)):
numpy_result = numpy_result,

assert len(cupy_result) == len(numpy_result)

# Check types
cupy_numpy_result_ndarrays = [
_convert_output_to_ndarray(
cupy_r, numpy_r, sp_name, check_sparse_format)
for cupy_r, numpy_r in zip(cupy_result, numpy_result)]

# Check dtypes
if type_check:
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
if cupy_r.dtype != numpy_r.dtype:
raise AssertionError(
'''ndarrays of different dtypes are returned.
cupy: {}
numpy: {}'''.format(cupy_r.dtype, numpy_r.dtype))

# Check contiguities
if contiguous_check:
for cupy_r, numpy_r in zip(cupy_result, numpy_result):
if isinstance(numpy_r, numpy.ndarray):
if (numpy_r.flags.c_contiguous
and not cupy_r.flags.c_contiguous):
raise AssertionError(
'The state of c_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.c_contiguous,
numpy_r.flags.c_contiguous))
if (numpy_r.flags.f_contiguous
and not cupy_r.flags.f_contiguous):
raise AssertionError(
'The state of f_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.f_contiguous,
numpy_r.flags.f_contiguous))

# Check shapes
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
assert cupy_r.shape == numpy_r.shape

# Check item values
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
# Behavior of assigning a negative value to an unsigned integer
# variable is undefined.
# nVidia GPUs and Intel CPUs behave differently.
# To avoid this difference, we need to ignore dimensions whose
# values are negative.

skip = False
if (_contains_signed_and_unsigned(kw)
and cupy_r.dtype in _unsigned_dtypes):
mask = _make_positive_mask(
self, impl, args, kw, name, sp_name, scipy_name)
if cupy_r.shape == ():
skip = (mask == 0).all()
else:
cupy_r = cupy_r[mask].get()
numpy_r = numpy_r[mask]

if not skip:
> check_func(cupy_r, numpy_r)

cupy/testing/_helper.py:343:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[30.36659675, 39.62975648, 53.45565341, 42.0701155 , 42.81412414],
[33.36838531, 37.73390254, 33.0117654...672, 44.03386405, 43.67148673, 48.63067102],
[32.28830047, 30.15609296, 36.65741325, 35.73179981, 40.69098504]])
desired = array([[32.49418447, 44.26508328, 55.58324819, 50.90632842, 53.13241351],
[36.78467189, 42.32410703, 50.5137596...954, 51.93015205, 56.78985728, 63.23111802],
[26.45539443, 35.1080233 , 46.86066347, 49.16227375, 60.05539763]])
rtol = 1e-05, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-05, atol=1e-05
E
E Mismatched elements: 20 / 20 (100%)
E Max absolute difference: 19.36441258
E Max relative difference: 0.34647974
E x: array([[30.366597, 39.629756, 53.455653, 42.070115, 42.814124],
E [33.368385, 37.733903, 33.011765, 32.58301 , 39.999025],
E [18.994361, 35.440507, 44.033864, 43.671487, 48.630671],
E [32.2883 , 30.156093, 36.657413, 35.7318 , 40.690985]])
E y: array([[32.494184, 44.265083, 55.583248, 50.906328, 53.132414],
E [36.784672, 42.324107, 50.51376 , 43.278745, 49.956693],
E [22.164907, 37.049 , 51.930152, 56.789857, 63.231118],
E [26.455394, 35.108023, 46.860663, 49.162274, 60.055398]])

cupy/testing/_array.py:24: AssertionError

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_filters.TestGenericFilter object at 0x7f9ca796ed00> parameter: {'filter'... 'numpy.float64'>, 'ksize': 4, 'mode': 'mirror', 'shape': (4, 5), 'function': <function rms_pyfunc at 0x7f9db3c38940>}>
args = (), kw = {}
cupy_result = (array([[29.110215 , 29.71338479, 34.73644898, 25.2421024 , 32.97375627],
[ 0. , 0. , 0. ... , 0. , 0. , 0. ],
[ 0. , 0. , 0. , 0. , 0. ]]),)
cupy_error = None
numpy_result = (array([[39.92050807, 39.92050807, 51.40005714, 43.376314 , 54.85586307],
[39.92050807, 39.92050807, 51.400057...2, 44.98891502, 43.33693082, 53.99120362],
[33.21871236, 33.21871236, 48.82046921, 44.04305038, 59.64480722]]),)
numpy_error = None
cupy_numpy_result_ndarrays = [(array([[29.110215 , 29.71338479, 34.73644898, 25.2421024 , 32.97375627],
[ 0. , 0. , 0. ...2, 44.98891502, 43.33693082, 53.99120362],
[33.21871236, 33.21871236, 48.82046921, 44.04305038, 59.64480722]]))]
cupy_r = array([[29.110215 , 29.71338479, 34.73644898, 25.2421024 , 32.97375627],
[ 0. , 0. , 0. ... , 0. , 0. , 0. ],
[ 0. , 0. , 0. , 0. , 0. ]])
numpy_r = array([[39.92050807, 39.92050807, 51.40005714, 43.376314 , 54.85586307],
[39.92050807, 39.92050807, 51.4000571...222, 44.98891502, 43.33693082, 53.99120362],
[33.21871236, 33.21871236, 48.82046921, 44.04305038, 59.64480722]])
skip = False

@_wraps_partial_xp(impl, name, sp_name, scipy_name)
def test_func(self, *args, **kw):
# Run cupy and numpy
(
cupy_result, cupy_error,
numpy_result, numpy_error) = (
_call_func_numpy_cupy(
self, impl, args, kw, name, sp_name, scipy_name))
assert cupy_result is not None or cupy_error is not None
assert numpy_result is not None or numpy_error is not None

# Check errors raised
if cupy_error or numpy_error:
_check_cupy_numpy_error(cupy_error,
numpy_error,
accept_error=accept_error)
return

# Check returned arrays

if not isinstance(cupy_result, (tuple, list)):
cupy_result = cupy_result,
if not isinstance(numpy_result, (tuple, list)):
numpy_result = numpy_result,

assert len(cupy_result) == len(numpy_result)

# Check types
cupy_numpy_result_ndarrays = [
_convert_output_to_ndarray(
cupy_r, numpy_r, sp_name, check_sparse_format)
for cupy_r, numpy_r in zip(cupy_result, numpy_result)]

# Check dtypes
if type_check:
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
if cupy_r.dtype != numpy_r.dtype:
raise AssertionError(
'''ndarrays of different dtypes are returned.
cupy: {}
numpy: {}'''.format(cupy_r.dtype, numpy_r.dtype))

# Check contiguities
if contiguous_check:
for cupy_r, numpy_r in zip(cupy_result, numpy_result):
if isinstance(numpy_r, numpy.ndarray):
if (numpy_r.flags.c_contiguous
and not cupy_r.flags.c_contiguous):
raise AssertionError(
'The state of c_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.c_contiguous,
numpy_r.flags.c_contiguous))
if (numpy_r.flags.f_contiguous
and not cupy_r.flags.f_contiguous):
raise AssertionError(
'The state of f_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.f_contiguous,
numpy_r.flags.f_contiguous))

# Check shapes
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
assert cupy_r.shape == numpy_r.shape

# Check item values
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
# Behavior of assigning a negative value to an unsigned integer
# variable is undefined.
# nVidia GPUs and Intel CPUs behave differently.
# To avoid this difference, we need to ignore dimensions whose
# values are negative.

skip = False
if (_contains_signed_and_unsigned(kw)
and cupy_r.dtype in _unsigned_dtypes):
mask = _make_positive_mask(
self, impl, args, kw, name, sp_name, scipy_name)
if cupy_r.shape == ():
skip = (mask == 0).all()
else:
cupy_r = cupy_r[mask].get()
numpy_r = numpy_r[mask]

if not skip:
> check_func(cupy_r, numpy_r)

cupy/testing/_helper.py:343:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[29.110215 , 29.71338479, 34.73644898, 25.2421024 , 32.97375627],
[ 0. , 0. , 0. ... , 0. , 0. , 0. ],
[ 0. , 0. , 0. , 0. , 0. ]])
desired = array([[39.92050807, 39.92050807, 51.40005714, 43.376314 , 54.85586307],
[39.92050807, 39.92050807, 51.4000571...222, 44.98891502, 43.33693082, 53.99120362],
[33.21871236, 33.21871236, 48.82046921, 44.04305038, 59.64480722]])
rtol = 1e-05, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-05, atol=1e-05
E
E Mismatched elements: 20 / 20 (100%)
E Max absolute difference: 59.64480722
E Max relative difference: 1.
E x: array([[29.110215, 29.713385, 34.736449, 25.242102, 32.973756],
E [ 0. , 0. , 0. , 0. , 0. ],
E [ 0. , 0. , 0. , 0. , 0. ],
E [ 0. , 0. , 0. , 0. , 0. ]])
E y: array([[39.920508, 39.920508, 51.400057, 43.376314, 54.855863],
E [39.920508, 39.920508, 51.400057, 43.376314, 54.855863],
E [34.334642, 34.334642, 44.988915, 43.336931, 53.991204],
E [33.218712, 33.218712, 48.820469, 44.04305 , 59.644807]])

cupy/testing/_array.py:24: AssertionError

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_filters.TestGenericFilter object at 0x7f9ca759a160> parameter: {'filter'...s 'numpy.float64'>, 'ksize': 3, 'mode': 'mirror', 'shape': (4, 5), 'function': <function lt_pyfunc at 0x7f9db29bc280>}>
args = (), kw = {}
cupy_result = (array([[4., 6., 3., 4., 3.],
[5., 7., 7., 5., 3.],
[6., 5., 4., 3., 2.],
[5., 7., 6., 4., 3.]]),)
cupy_error = None
numpy_result = (array([[4., 6., 3., 3., 2.],
[5., 0., 6., 8., 1.],
[8., 3., 3., 7., 0.],
[2., 0., 6., 4., 4.]]),)
numpy_error = None
cupy_numpy_result_ndarrays = [(array([[4., 6., 3., 4., 3.],
[5., 7., 7., 5., 3.],
[6., 5., 4., 3., 2.],
[5., 7., 6., 4., 3.]]), array([[4., 6., 3., 3., 2.],
[5., 0., 6., 8., 1.],
[8., 3., 3., 7., 0.],
[2., 0., 6., 4., 4.]]))]
cupy_r = array([[4., 6., 3., 4., 3.],
[5., 7., 7., 5., 3.],
[6., 5., 4., 3., 2.],
[5., 7., 6., 4., 3.]])
numpy_r = array([[4., 6., 3., 3., 2.],
[5., 0., 6., 8., 1.],
[8., 3., 3., 7., 0.],
[2., 0., 6., 4., 4.]])
skip = False

@_wraps_partial_xp(impl, name, sp_name, scipy_name)
def test_func(self, *args, **kw):
# Run cupy and numpy
(
cupy_result, cupy_error,
numpy_result, numpy_error) = (
_call_func_numpy_cupy(
self, impl, args, kw, name, sp_name, scipy_name))
assert cupy_result is not None or cupy_error is not None
assert numpy_result is not None or numpy_error is not None

# Check errors raised
if cupy_error or numpy_error:
_check_cupy_numpy_error(cupy_error,
numpy_error,
accept_error=accept_error)
return

# Check returned arrays

if not isinstance(cupy_result, (tuple, list)):
cupy_result = cupy_result,
if not isinstance(numpy_result, (tuple, list)):
numpy_result = numpy_result,

assert len(cupy_result) == len(numpy_result)

# Check types
cupy_numpy_result_ndarrays = [
_convert_output_to_ndarray(
cupy_r, numpy_r, sp_name, check_sparse_format)
for cupy_r, numpy_r in zip(cupy_result, numpy_result)]

# Check dtypes
if type_check:
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
if cupy_r.dtype != numpy_r.dtype:
raise AssertionError(
'''ndarrays of different dtypes are returned.
cupy: {}
numpy: {}'''.format(cupy_r.dtype, numpy_r.dtype))

# Check contiguities
if contiguous_check:
for cupy_r, numpy_r in zip(cupy_result, numpy_result):
if isinstance(numpy_r, numpy.ndarray):
if (numpy_r.flags.c_contiguous
and not cupy_r.flags.c_contiguous):
raise AssertionError(
'The state of c_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.c_contiguous,
numpy_r.flags.c_contiguous))
if (numpy_r.flags.f_contiguous
and not cupy_r.flags.f_contiguous):
raise AssertionError(
'The state of f_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.f_contiguous,
numpy_r.flags.f_contiguous))

# Check shapes
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
assert cupy_r.shape == numpy_r.shape

# Check item values
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
# Behavior of assigning a negative value to an unsigned integer
# variable is undefined.
# nVidia GPUs and Intel CPUs behave differently.
# To avoid this difference, we need to ignore dimensions whose
# values are negative.

skip = False
if (_contains_signed_and_unsigned(kw)
and cupy_r.dtype in _unsigned_dtypes):
mask = _make_positive_mask(
self, impl, args, kw, name, sp_name, scipy_name)
if cupy_r.shape == ():
skip = (mask == 0).all()
else:
cupy_r = cupy_r[mask].get()
numpy_r = numpy_r[mask]

if not skip:
> check_func(cupy_r, numpy_r)

cupy/testing/_helper.py:343:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[4., 6., 3., 4., 3.],
[5., 7., 7., 5., 3.],
[6., 5., 4., 3., 2.],
[5., 7., 6., 4., 3.]])
desired = array([[4., 6., 3., 3., 2.],
[5., 0., 6., 8., 1.],
[8., 3., 3., 7., 0.],
[2., 0., 6., 4., 4.]])
rtol = 1e-05, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-05, atol=1e-05
E
E Mismatched elements: 14 / 20 (70%)
E Max absolute difference: 7.
E Max relative difference: 2.
E x: array([[4., 6., 3., 4., 3.],
E [5., 7., 7., 5., 3.],
E [6., 5., 4., 3., 2.],
E [5., 7., 6., 4., 3.]])
E y: array([[4., 6., 3., 3., 2.],
E [5., 0., 6., 8., 1.],
E [8., 3., 3., 7., 0.],
E [2., 0., 6., 4., 4.]])

cupy/testing/_array.py:24: AssertionError

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_filters.TestGenericFilter object at 0x7f9ca6dba190> parameter: {'filter'...s 'numpy.float64'>, 'ksize': 4, 'mode': 'mirror', 'shape': (4, 5), 'function': <function lt_pyfunc at 0x7f9db29bc280>}>
args = (), kw = {}
cupy_result = (array([[15., 5., 13., 8., 11.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.]]),)
cupy_error = None
numpy_result = (array([[ 8., 11., 4., 10., 7.],
[14., 0., 7., 4., 8.],
[ 8., 5., 11., 5., 5.],
[14., 0., 1., 0., 7.]]),)
numpy_error = None
cupy_numpy_result_ndarrays = [(array([[15., 5., 13., 8., 11.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., ...4., 10., 7.],
[14., 0., 7., 4., 8.],
[ 8., 5., 11., 5., 5.],
[14., 0., 1., 0., 7.]]))]
cupy_r = array([[15., 5., 13., 8., 11.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.]])
numpy_r = array([[ 8., 11., 4., 10., 7.],
[14., 0., 7., 4., 8.],
[ 8., 5., 11., 5., 5.],
[14., 0., 1., 0., 7.]])
skip = False

@_wraps_partial_xp(impl, name, sp_name, scipy_name)
def test_func(self, *args, **kw):
# Run cupy and numpy
(
cupy_result, cupy_error,
numpy_result, numpy_error) = (
_call_func_numpy_cupy(
self, impl, args, kw, name, sp_name, scipy_name))
assert cupy_result is not None or cupy_error is not None
assert numpy_result is not None or numpy_error is not None

# Check errors raised
if cupy_error or numpy_error:
_check_cupy_numpy_error(cupy_error,
numpy_error,
accept_error=accept_error)
return

# Check returned arrays

if not isinstance(cupy_result, (tuple, list)):
cupy_result = cupy_result,
if not isinstance(numpy_result, (tuple, list)):
numpy_result = numpy_result,

assert len(cupy_result) == len(numpy_result)

# Check types
cupy_numpy_result_ndarrays = [
_convert_output_to_ndarray(
cupy_r, numpy_r, sp_name, check_sparse_format)
for cupy_r, numpy_r in zip(cupy_result, numpy_result)]

# Check dtypes
if type_check:
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
if cupy_r.dtype != numpy_r.dtype:
raise AssertionError(
'''ndarrays of different dtypes are returned.
cupy: {}
numpy: {}'''.format(cupy_r.dtype, numpy_r.dtype))

# Check contiguities
if contiguous_check:
for cupy_r, numpy_r in zip(cupy_result, numpy_result):
if isinstance(numpy_r, numpy.ndarray):
if (numpy_r.flags.c_contiguous
and not cupy_r.flags.c_contiguous):
raise AssertionError(
'The state of c_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.c_contiguous,
numpy_r.flags.c_contiguous))
if (numpy_r.flags.f_contiguous
and not cupy_r.flags.f_contiguous):
raise AssertionError(
'The state of f_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.f_contiguous,
numpy_r.flags.f_contiguous))

# Check shapes
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
assert cupy_r.shape == numpy_r.shape

# Check item values
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
# Behavior of assigning a negative value to an unsigned integer
# variable is undefined.
# nVidia GPUs and Intel CPUs behave differently.
# To avoid this difference, we need to ignore dimensions whose
# values are negative.

skip = False
if (_contains_signed_and_unsigned(kw)
and cupy_r.dtype in _unsigned_dtypes):
mask = _make_positive_mask(
self, impl, args, kw, name, sp_name, scipy_name)
if cupy_r.shape == ():
skip = (mask == 0).all()
else:
cupy_r = cupy_r[mask].get()
numpy_r = numpy_r[mask]

if not skip:
> check_func(cupy_r, numpy_r)

cupy/testing/_helper.py:343:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[15., 5., 13., 8., 11.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.]])
desired = array([[ 8., 11., 4., 10., 7.],
[14., 0., 7., 4., 8.],
[ 8., 5., 11., 5., 5.],
[14., 0., 1., 0., 7.]])
rtol = 1e-05, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-05, atol=1e-05
E
E Mismatched elements: 17 / 20 (85%)
E Max absolute difference: 14.
E Max relative difference: 2.25
E x: array([[15., 5., 13., 8., 11.],
E [ 0., 0., 0., 0., 0.],
E [ 0., 0., 0., 0., 0.],
E [ 0., 0., 0., 0., 0.]])
E y: array([[ 8., 11., 4., 10., 7.],
E [14., 0., 7., 4., 8.],
E [ 8., 5., 11., 5., 5.],
E [14., 0., 1., 0., 7.]])

cupy/testing/_array.py:24: AssertionError

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_filters.TestGenericFilter object at 0x7f9ca6db5c70> parameter: {'filter'...ss 'numpy.uint8'>, 'ksize': 3, 'mode': 'mirror', 'shape': (4, 5), 'function': <function rms_pyfunc at 0x7f9db3c38940>}>
args = (), kw = {}
cupy_result = (array([[21, 28, 45, 28, 29],
[28, 24, 27, 19, 21],
[14, 25, 40, 31, 32],
[28, 19, 33, 25, 26]], dtype=uint8),)
cupy_error = None
numpy_result = (array([[31, 36, 54, 42, 44],
[32, 37, 44, 33, 44],
[16, 36, 54, 41, 63],
[24, 30, 40, 45, 48]], dtype=uint8),)
numpy_error = None
cupy_numpy_result_ndarrays = [(array([[21, 28, 45, 28, 29],
[28, 24, 27, 19, 21],
[14, 25, 40, 31, 32],
[28, 19, 33, 25, 26]],...36, 54, 42, 44],
[32, 37, 44, 33, 44],
[16, 36, 54, 41, 63],
[24, 30, 40, 45, 48]], dtype=uint8))]
cupy_r = array([[21, 28, 45, 28, 29],
[28, 24, 27, 19, 21],
[14, 25, 40, 31, 32],
[28, 19, 33, 25, 26]], dtype=uint8)
numpy_r = array([[31, 36, 54, 42, 44],
[32, 37, 44, 33, 44],
[16, 36, 54, 41, 63],
[24, 30, 40, 45, 48]], dtype=uint8)
skip = False

@_wraps_partial_xp(impl, name, sp_name, scipy_name)
def test_func(self, *args, **kw):
# Run cupy and numpy
(
cupy_result, cupy_error,
numpy_result, numpy_error) = (
_call_func_numpy_cupy(
self, impl, args, kw, name, sp_name, scipy_name))
assert cupy_result is not None or cupy_error is not None
assert numpy_result is not None or numpy_error is not None

# Check errors raised
if cupy_error or numpy_error:
_check_cupy_numpy_error(cupy_error,
numpy_error,
accept_error=accept_error)
return

# Check returned arrays

if not isinstance(cupy_result, (tuple, list)):
cupy_result = cupy_result,
if not isinstance(numpy_result, (tuple, list)):
numpy_result = numpy_result,

assert len(cupy_result) == len(numpy_result)

# Check types
cupy_numpy_result_ndarrays = [
_convert_output_to_ndarray(
cupy_r, numpy_r, sp_name, check_sparse_format)
for cupy_r, numpy_r in zip(cupy_result, numpy_result)]

# Check dtypes
if type_check:
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
if cupy_r.dtype != numpy_r.dtype:
raise AssertionError(
'''ndarrays of different dtypes are returned.
cupy: {}
numpy: {}'''.format(cupy_r.dtype, numpy_r.dtype))

# Check contiguities
if contiguous_check:
for cupy_r, numpy_r in zip(cupy_result, numpy_result):
if isinstance(numpy_r, numpy.ndarray):
if (numpy_r.flags.c_contiguous
and not cupy_r.flags.c_contiguous):
raise AssertionError(
'The state of c_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.c_contiguous,
numpy_r.flags.c_contiguous))
if (numpy_r.flags.f_contiguous
and not cupy_r.flags.f_contiguous):
raise AssertionError(
'The state of f_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.f_contiguous,
numpy_r.flags.f_contiguous))

# Check shapes
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
assert cupy_r.shape == numpy_r.shape

# Check item values
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
# Behavior of assigning a negative value to an unsigned integer
# variable is undefined.
# nVidia GPUs and Intel CPUs behave differently.
# To avoid this difference, we need to ignore dimensions whose
# values are negative.

skip = False
if (_contains_signed_and_unsigned(kw)
and cupy_r.dtype in _unsigned_dtypes):
mask = _make_positive_mask(
self, impl, args, kw, name, sp_name, scipy_name)
if cupy_r.shape == ():
skip = (mask == 0).all()
else:
cupy_r = cupy_r[mask].get()
numpy_r = numpy_r[mask]

if not skip:
> check_func(cupy_r, numpy_r)

cupy/testing/_helper.py:343:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[21, 28, 45, 28, 29],
[28, 24, 27, 19, 21],
[14, 25, 40, 31, 32],
[28, 19, 33, 25, 26]], dtype=uint8)
desired = array([[31, 36, 54, 42, 44],
[32, 37, 44, 33, 44],
[16, 36, 54, 41, 63],
[24, 30, 40, 45, 48]], dtype=uint8)
rtol = 1e-05, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-05, atol=1e-05
E
E Mismatched elements: 20 / 20 (100%)
E Max absolute difference: 254
E Max relative difference: 15.875
E x: array([[21, 28, 45, 28, 29],
E [28, 24, 27, 19, 21],
E [14, 25, 40, 31, 32],
E [28, 19, 33, 25, 26]], dtype=uint8)
E y: array([[31, 36, 54, 42, 44],
E [32, 37, 44, 33, 44],
E [16, 36, 54, 41, 63],
E [24, 30, 40, 45, 48]], dtype=uint8)

cupy/testing/_array.py:24: AssertionError

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_filters.TestGenericFilter object at 0x7f9ca6594b50> parameter: {'filter'...ss 'numpy.uint8'>, 'ksize': 4, 'mode': 'mirror', 'shape': (4, 5), 'function': <function rms_pyfunc at 0x7f9db3c38940>}>
args = (), kw = {}
cupy_result = (array([[23, 27, 36, 28, 53],
[ 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0]], dtype=uint8),)
cupy_error = None
numpy_result = (array([[31, 37, 37, 34, 51],
[36, 33, 47, 34, 49],
[32, 30, 35, 33, 43],
[26, 31, 44, 32, 61]], dtype=uint8),)
numpy_error = None
cupy_numpy_result_ndarrays = [(array([[23, 27, 36, 28, 53],
[ 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0]],...37, 37, 34, 51],
[36, 33, 47, 34, 49],
[32, 30, 35, 33, 43],
[26, 31, 44, 32, 61]], dtype=uint8))]
cupy_r = array([[23, 27, 36, 28, 53],
[ 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0]], dtype=uint8)
numpy_r = array([[31, 37, 37, 34, 51],
[36, 33, 47, 34, 49],
[32, 30, 35, 33, 43],
[26, 31, 44, 32, 61]], dtype=uint8)
skip = False

@_wraps_partial_xp(impl, name, sp_name, scipy_name)
def test_func(self, *args, **kw):
# Run cupy and numpy
(
cupy_result, cupy_error,
numpy_result, numpy_error) = (
_call_func_numpy_cupy(
self, impl, args, kw, name, sp_name, scipy_name))
assert cupy_result is not None or cupy_error is not None
assert numpy_result is not None or numpy_error is not None

# Check errors raised
if cupy_error or numpy_error:
_check_cupy_numpy_error(cupy_error,
numpy_error,
accept_error=accept_error)
return

# Check returned arrays

if not isinstance(cupy_result, (tuple, list)):
cupy_result = cupy_result,
if not isinstance(numpy_result, (tuple, list)):
numpy_result = numpy_result,

assert len(cupy_result) == len(numpy_result)

# Check types
cupy_numpy_result_ndarrays = [
_convert_output_to_ndarray(
cupy_r, numpy_r, sp_name, check_sparse_format)
for cupy_r, numpy_r in zip(cupy_result, numpy_result)]

# Check dtypes
if type_check:
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
if cupy_r.dtype != numpy_r.dtype:
raise AssertionError(
'''ndarrays of different dtypes are returned.
cupy: {}
numpy: {}'''.format(cupy_r.dtype, numpy_r.dtype))

# Check contiguities
if contiguous_check:
for cupy_r, numpy_r in zip(cupy_result, numpy_result):
if isinstance(numpy_r, numpy.ndarray):
if (numpy_r.flags.c_contiguous
and not cupy_r.flags.c_contiguous):
raise AssertionError(
'The state of c_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.c_contiguous,
numpy_r.flags.c_contiguous))
if (numpy_r.flags.f_contiguous
and not cupy_r.flags.f_contiguous):
raise AssertionError(
'The state of f_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.f_contiguous,
numpy_r.flags.f_contiguous))

# Check shapes
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
assert cupy_r.shape == numpy_r.shape

# Check item values
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
# Behavior of assigning a negative value to an unsigned integer
# variable is undefined.
# nVidia GPUs and Intel CPUs behave differently.
# To avoid this difference, we need to ignore dimensions whose
# values are negative.

skip = False
if (_contains_signed_and_unsigned(kw)
and cupy_r.dtype in _unsigned_dtypes):
mask = _make_positive_mask(
self, impl, args, kw, name, sp_name, scipy_name)
if cupy_r.shape == ():
skip = (mask == 0).all()
else:
cupy_r = cupy_r[mask].get()
numpy_r = numpy_r[mask]

if not skip:
> check_func(cupy_r, numpy_r)

cupy/testing/_helper.py:343:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[23, 27, 36, 28, 53],
[ 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0]], dtype=uint8)
desired = array([[31, 37, 37, 34, 51],
[36, 33, 47, 34, 49],
[32, 30, 35, 33, 43],
[26, 31, 44, 32, 61]], dtype=uint8)
rtol = 1e-05, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-05, atol=1e-05
E
E Mismatched elements: 20 / 20 (100%)
E Max absolute difference: 255
E Max relative difference: 8.84615385
E x: array([[23, 27, 36, 28, 53],
E [ 0, 0, 0, 0, 0],
E [ 0, 0, 0, 0, 0],
E [ 0, 0, 0, 0, 0]], dtype=uint8)
E y: array([[31, 37, 37, 34, 51],
E [36, 33, 47, 34, 49],
E [32, 30, 35, 33, 43],
E [26, 31, 44, 32, 61]], dtype=uint8)

cupy/testing/_array.py:24: AssertionError

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_filters.TestGenericFilter object at 0x7f9ca6d9ebe0> parameter: {'filter'... 'numpy.float64'>, 'ksize': 3, 'mode': 'mirror', 'shape': (4, 5), 'function': <function rms_pyfunc at 0x7f9db3c38940>}>
args = (), kw = {}
cupy_result = (array([[32.00449826, 37.68575782, 60.8028936 , 38.48790895, 39.21631239],
[34.60326543, 32.2532409 , 33.257219...9, 51.41878991, 42.0040045 , 51.31070106],
[33.21458492, 22.51034287, 37.94448098, 37.08985252, 37.51394469]]),)
cupy_error = None
numpy_result = (array([[34.73996818, 43.64546371, 63.5383726 , 49.84875414, 52.48268444],
[37.33873469, 42.72655042, 49.589277...5, 62.15186111, 50.87288873, 72.5746653 ],
[29.90948782, 36.17835396, 46.34962956, 49.94860122, 54.16193588]]),)
numpy_error = None
cupy_numpy_result_ndarrays = [(array([[32.00449826, 37.68575782, 60.8028936 , 38.48790895, 39.21631239],
[34.60326543, 32.2532409 , 33.25721...5, 62.15186111, 50.87288873, 72.5746653 ],
[29.90948782, 36.17835396, 46.34962956, 49.94860122, 54.16193588]]))]
cupy_r = array([[32.00449826, 37.68575782, 60.8028936 , 38.48790895, 39.21631239],
[34.60326543, 32.2532409 , 33.2572195...229, 51.41878991, 42.0040045 , 51.31070106],
[33.21458492, 22.51034287, 37.94448098, 37.08985252, 37.51394469]])
numpy_r = array([[34.73996818, 43.64546371, 63.5383726 , 49.84875414, 52.48268444],
[37.33873469, 42.72655042, 49.5892777...725, 62.15186111, 50.87288873, 72.5746653 ],
[29.90948782, 36.17835396, 46.34962956, 49.94860122, 54.16193588]])
skip = False

@_wraps_partial_xp(impl, name, sp_name, scipy_name)
def test_func(self, *args, **kw):
# Run cupy and numpy
(
cupy_result, cupy_error,
numpy_result, numpy_error) = (
_call_func_numpy_cupy(
self, impl, args, kw, name, sp_name, scipy_name))
assert cupy_result is not None or cupy_error is not None
assert numpy_result is not None or numpy_error is not None

# Check errors raised
if cupy_error or numpy_error:
_check_cupy_numpy_error(cupy_error,
numpy_error,
accept_error=accept_error)
return

# Check returned arrays

if not isinstance(cupy_result, (tuple, list)):
cupy_result = cupy_result,
if not isinstance(numpy_result, (tuple, list)):
numpy_result = numpy_result,

assert len(cupy_result) == len(numpy_result)

# Check types
cupy_numpy_result_ndarrays = [
_convert_output_to_ndarray(
cupy_r, numpy_r, sp_name, check_sparse_format)
for cupy_r, numpy_r in zip(cupy_result, numpy_result)]

# Check dtypes
if type_check:
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
if cupy_r.dtype != numpy_r.dtype:
raise AssertionError(
'''ndarrays of different dtypes are returned.
cupy: {}
numpy: {}'''.format(cupy_r.dtype, numpy_r.dtype))

# Check contiguities
if contiguous_check:
for cupy_r, numpy_r in zip(cupy_result, numpy_result):
if isinstance(numpy_r, numpy.ndarray):
if (numpy_r.flags.c_contiguous
and not cupy_r.flags.c_contiguous):
raise AssertionError(
'The state of c_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.c_contiguous,
numpy_r.flags.c_contiguous))
if (numpy_r.flags.f_contiguous
and not cupy_r.flags.f_contiguous):
raise AssertionError(
'The state of f_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.f_contiguous,
numpy_r.flags.f_contiguous))

# Check shapes
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
assert cupy_r.shape == numpy_r.shape

# Check item values
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
# Behavior of assigning a negative value to an unsigned integer
# variable is undefined.
# nVidia GPUs and Intel CPUs behave differently.
# To avoid this difference, we need to ignore dimensions whose
# values are negative.

skip = False
if (_contains_signed_and_unsigned(kw)
and cupy_r.dtype in _unsigned_dtypes):
mask = _make_positive_mask(
self, impl, args, kw, name, sp_name, scipy_name)
if cupy_r.shape == ():
skip = (mask == 0).all()
else:
cupy_r = cupy_r[mask].get()
numpy_r = numpy_r[mask]

if not skip:
> check_func(cupy_r, numpy_r)

cupy/testing/_helper.py:343:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[32.00449826, 37.68575782, 60.8028936 , 38.48790895, 39.21631239],
[34.60326543, 32.2532409 , 33.2572195...229, 51.41878991, 42.0040045 , 51.31070106],
[33.21458492, 22.51034287, 37.94448098, 37.08985252, 37.51394469]])
desired = array([[34.73996818, 43.64546371, 63.5383726 , 49.84875414, 52.48268444],
[37.33873469, 42.72655042, 49.5892777...725, 62.15186111, 50.87288873, 72.5746653 ],
[29.90948782, 36.17835396, 46.34962956, 49.94860122, 54.16193588]])
rtol = 1e-05, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-05, atol=1e-05
E
E Mismatched elements: 20 / 20 (100%)
E Max absolute difference: 21.26396424
E Max relative difference: 0.37779527
E x: array([[32.004498, 37.685758, 60.802894, 38.487909, 39.216312],
E [34.603265, 32.253241, 33.25722 , 33.041408, 36.624282],
E [20.112677, 38.150832, 51.41879 , 42.004005, 51.310701],
E [33.214585, 22.510343, 37.944481, 37.089853, 37.513945]])
E y: array([[34.739968, 43.645464, 63.538373, 49.848754, 52.482684],
E [37.338735, 42.72655 , 49.589278, 37.768093, 49.890655],
E [19.537204, 43.529837, 62.151861, 50.872889, 72.574665],
E [29.909488, 36.178354, 46.34963 , 49.948601, 54.161936]])

cupy/testing/_array.py:24: AssertionError

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_filters.TestGenericFilter object at 0x7f9ca65946a0> parameter: {'filter'... 'numpy.float64'>, 'ksize': 4, 'mode': 'mirror', 'shape': (4, 5), 'function': <function rms_pyfunc at 0x7f9db3c38940>}>
args = (), kw = {}
cupy_result = (array([[21.27808861, 29.80163272, 37.25897052, 32.87956485, 40.18680146],
[ 0. , 0. , 0. ... , 0. , 0. , 0. ],
[ 0. , 0. , 0. , 0. , 0. ]]),)
cupy_error = None
numpy_result = (array([[36.86077635, 42.87616583, 43.41972747, 39.82804323, 58.74618737],
[42.04291274, 39.49732697, 56.260026...8, 40.06613219, 37.53324325, 49.79207175],
[31.44112421, 37.6867121 , 51.65417609, 39.59452747, 70.43768385]]),)
numpy_error = None
cupy_numpy_result_ndarrays = [(array([[21.27808861, 29.80163272, 37.25897052, 32.87956485, 40.18680146],
[ 0. , 0. , 0. ...8, 40.06613219, 37.53324325, 49.79207175],
[31.44112421, 37.6867121 , 51.65417609, 39.59452747, 70.43768385]]))]
cupy_r = array([[21.27808861, 29.80163272, 37.25897052, 32.87956485, 40.18680146],
[ 0. , 0. , 0. ... , 0. , 0. , 0. ],
[ 0. , 0. , 0. , 0. , 0. ]])
numpy_r = array([[36.86077635, 42.87616583, 43.41972747, 39.82804323, 58.74618737],
[42.04291274, 39.49732697, 56.2600260...358, 40.06613219, 37.53324325, 49.79207175],
[31.44112421, 37.6867121 , 51.65417609, 39.59452747, 70.43768385]])
skip = False

@_wraps_partial_xp(impl, name, sp_name, scipy_name)
def test_func(self, *args, **kw):
# Run cupy and numpy
(
cupy_result, cupy_error,
numpy_result, numpy_error) = (
_call_func_numpy_cupy(
self, impl, args, kw, name, sp_name, scipy_name))
assert cupy_result is not None or cupy_error is not None
assert numpy_result is not None or numpy_error is not None

# Check errors raised
if cupy_error or numpy_error:
_check_cupy_numpy_error(cupy_error,
numpy_error,
accept_error=accept_error)
return

# Check returned arrays

if not isinstance(cupy_result, (tuple, list)):
cupy_result = cupy_result,
if not isinstance(numpy_result, (tuple, list)):
numpy_result = numpy_result,

assert len(cupy_result) == len(numpy_result)

# Check types
cupy_numpy_result_ndarrays = [
_convert_output_to_ndarray(
cupy_r, numpy_r, sp_name, check_sparse_format)
for cupy_r, numpy_r in zip(cupy_result, numpy_result)]

# Check dtypes
if type_check:
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
if cupy_r.dtype != numpy_r.dtype:
raise AssertionError(
'''ndarrays of different dtypes are returned.
cupy: {}
numpy: {}'''.format(cupy_r.dtype, numpy_r.dtype))

# Check contiguities
if contiguous_check:
for cupy_r, numpy_r in zip(cupy_result, numpy_result):
if isinstance(numpy_r, numpy.ndarray):
if (numpy_r.flags.c_contiguous
and not cupy_r.flags.c_contiguous):
raise AssertionError(
'The state of c_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.c_contiguous,
numpy_r.flags.c_contiguous))
if (numpy_r.flags.f_contiguous
and not cupy_r.flags.f_contiguous):
raise AssertionError(
'The state of f_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.f_contiguous,
numpy_r.flags.f_contiguous))

# Check shapes
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
assert cupy_r.shape == numpy_r.shape

# Check item values
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
# Behavior of assigning a negative value to an unsigned integer
# variable is undefined.
# nVidia GPUs and Intel CPUs behave differently.
# To avoid this difference, we need to ignore dimensions whose
# values are negative.

skip = False
if (_contains_signed_and_unsigned(kw)
and cupy_r.dtype in _unsigned_dtypes):
mask = _make_positive_mask(
self, impl, args, kw, name, sp_name, scipy_name)
if cupy_r.shape == ():
skip = (mask == 0).all()
else:
cupy_r = cupy_r[mask].get()
numpy_r = numpy_r[mask]

if not skip:
> check_func(cupy_r, numpy_r)

cupy/testing/_helper.py:343:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[21.27808861, 29.80163272, 37.25897052, 32.87956485, 40.18680146],
[ 0. , 0. , 0. ... , 0. , 0. , 0. ],
[ 0. , 0. , 0. , 0. , 0. ]])
desired = array([[36.86077635, 42.87616583, 43.41972747, 39.82804323, 58.74618737],
[42.04291274, 39.49732697, 56.2600260...358, 40.06613219, 37.53324325, 49.79207175],
[31.44112421, 37.6867121 , 51.65417609, 39.59452747, 70.43768385]])
rtol = 1e-05, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-05, atol=1e-05
E
E Mismatched elements: 20 / 20 (100%)
E Max absolute difference: 70.43768385
E Max relative difference: 1.
E x: array([[21.278089, 29.801633, 37.258971, 32.879565, 40.186801],
E [ 0. , 0. , 0. , 0. , 0. ],
E [ 0. , 0. , 0. , 0. , 0. ],
E [ 0. , 0. , 0. , 0. , 0. ]])
E y: array([[36.860776, 42.876166, 43.419727, 39.828043, 58.746187],
E [42.042913, 39.497327, 56.260026, 40.67984 , 58.57918 ],
E [36.303403, 34.455314, 40.066132, 37.533243, 49.792072],
E [31.441124, 37.686712, 51.654176, 39.594527, 70.437684]])

cupy/testing/_array.py:24: AssertionError

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_filters.TestGenericFilter object at 0x7f9ca659b100> parameter: {'filter'...s 'numpy.float64'>, 'ksize': 3, 'mode': 'mirror', 'shape': (4, 5), 'function': <function lt_pyfunc at 0x7f9db29bc280>}>
args = (), kw = {}
cupy_result = (array([[5., 3., 2., 4., 3.],
[1., 5., 1., 5., 6.],
[4., 4., 1., 3., 5.],
[1., 1., 1., 4., 4.]]),)
cupy_error = None
numpy_result = (array([[5., 2., 2., 3., 2.],
[0., 4., 0., 5., 5.],
[4., 4., 1., 2., 3.],
[0., 0., 0., 3., 2.]]),)
numpy_error = None
cupy_numpy_result_ndarrays = [(array([[5., 3., 2., 4., 3.],
[1., 5., 1., 5., 6.],
[4., 4., 1., 3., 5.],
[1., 1., 1., 4., 4.]]), array([[5., 2., 2., 3., 2.],
[0., 4., 0., 5., 5.],
[4., 4., 1., 2., 3.],
[0., 0., 0., 3., 2.]]))]
cupy_r = array([[5., 3., 2., 4., 3.],
[1., 5., 1., 5., 6.],
[4., 4., 1., 3., 5.],
[1., 1., 1., 4., 4.]])
numpy_r = array([[5., 2., 2., 3., 2.],
[0., 4., 0., 5., 5.],
[4., 4., 1., 2., 3.],
[0., 0., 0., 3., 2.]])
skip = False

@_wraps_partial_xp(impl, name, sp_name, scipy_name)
def test_func(self, *args, **kw):
# Run cupy and numpy
(
cupy_result, cupy_error,
numpy_result, numpy_error) = (
_call_func_numpy_cupy(
self, impl, args, kw, name, sp_name, scipy_name))
assert cupy_result is not None or cupy_error is not None
assert numpy_result is not None or numpy_error is not None

# Check errors raised
if cupy_error or numpy_error:
_check_cupy_numpy_error(cupy_error,
numpy_error,
accept_error=accept_error)
return

# Check returned arrays

if not isinstance(cupy_result, (tuple, list)):
cupy_result = cupy_result,
if not isinstance(numpy_result, (tuple, list)):
numpy_result = numpy_result,

assert len(cupy_result) == len(numpy_result)

# Check types
cupy_numpy_result_ndarrays = [
_convert_output_to_ndarray(
cupy_r, numpy_r, sp_name, check_sparse_format)
for cupy_r, numpy_r in zip(cupy_result, numpy_result)]

# Check dtypes
if type_check:
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
if cupy_r.dtype != numpy_r.dtype:
raise AssertionError(
'''ndarrays of different dtypes are returned.
cupy: {}
numpy: {}'''.format(cupy_r.dtype, numpy_r.dtype))

# Check contiguities
if contiguous_check:
for cupy_r, numpy_r in zip(cupy_result, numpy_result):
if isinstance(numpy_r, numpy.ndarray):
if (numpy_r.flags.c_contiguous
and not cupy_r.flags.c_contiguous):
raise AssertionError(
'The state of c_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.c_contiguous,
numpy_r.flags.c_contiguous))
if (numpy_r.flags.f_contiguous
and not cupy_r.flags.f_contiguous):
raise AssertionError(
'The state of f_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.f_contiguous,
numpy_r.flags.f_contiguous))

# Check shapes
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
assert cupy_r.shape == numpy_r.shape

# Check item values
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
# Behavior of assigning a negative value to an unsigned integer
# variable is undefined.
# nVidia GPUs and Intel CPUs behave differently.
# To avoid this difference, we need to ignore dimensions whose
# values are negative.

skip = False
if (_contains_signed_and_unsigned(kw)
and cupy_r.dtype in _unsigned_dtypes):
mask = _make_positive_mask(
self, impl, args, kw, name, sp_name, scipy_name)
if cupy_r.shape == ():
skip = (mask == 0).all()
else:
cupy_r = cupy_r[mask].get()
numpy_r = numpy_r[mask]

if not skip:
> check_func(cupy_r, numpy_r)

cupy/testing/_helper.py:343:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[5., 3., 2., 4., 3.],
[1., 5., 1., 5., 6.],
[4., 4., 1., 3., 5.],
[1., 1., 1., 4., 4.]])
desired = array([[5., 2., 2., 3., 2.],
[0., 4., 0., 5., 5.],
[4., 4., 1., 2., 3.],
[0., 0., 0., 3., 2.]])
rtol = 1e-05, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-05, atol=1e-05
E
E Mismatched elements: 14 / 20 (70%)
E Max absolute difference: 2.
E Max relative difference: 1.
E x: array([[5., 3., 2., 4., 3.],
E [1., 5., 1., 5., 6.],
E [4., 4., 1., 3., 5.],
E [1., 1., 1., 4., 4.]])
E y: array([[5., 2., 2., 3., 2.],
E [0., 4., 0., 5., 5.],
E [4., 4., 1., 2., 3.],
E [0., 0., 0., 3., 2.]])

cupy/testing/_array.py:24: AssertionError

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_filters.TestGenericFilter object at 0x7f9ca65a5250> parameter: {'filter'...s 'numpy.float64'>, 'ksize': 4, 'mode': 'mirror', 'shape': (4, 5), 'function': <function lt_pyfunc at 0x7f9db29bc280>}>
args = (), kw = {}
cupy_result = (array([[ 6., 10., 10., 3., 9.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.]]),)
cupy_error = None
numpy_result = (array([[ 0., 10., 10., 1., 8.],
[ 7., 6., 2., 2., 2.],
[ 1., 10., 10., 2., 9.],
[ 4., 5., 9., 1., 6.]]),)
numpy_error = None
cupy_numpy_result_ndarrays = [(array([[ 6., 10., 10., 3., 9.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., ...0., 1., 8.],
[ 7., 6., 2., 2., 2.],
[ 1., 10., 10., 2., 9.],
[ 4., 5., 9., 1., 6.]]))]
cupy_r = array([[ 6., 10., 10., 3., 9.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.]])
numpy_r = array([[ 0., 10., 10., 1., 8.],
[ 7., 6., 2., 2., 2.],
[ 1., 10., 10., 2., 9.],
[ 4., 5., 9., 1., 6.]])
skip = False

@_wraps_partial_xp(impl, name, sp_name, scipy_name)
def test_func(self, *args, **kw):
# Run cupy and numpy
(
cupy_result, cupy_error,
numpy_result, numpy_error) = (
_call_func_numpy_cupy(
self, impl, args, kw, name, sp_name, scipy_name))
assert cupy_result is not None or cupy_error is not None
assert numpy_result is not None or numpy_error is not None

# Check errors raised
if cupy_error or numpy_error:
_check_cupy_numpy_error(cupy_error,
numpy_error,
accept_error=accept_error)
return

# Check returned arrays

if not isinstance(cupy_result, (tuple, list)):
cupy_result = cupy_result,
if not isinstance(numpy_result, (tuple, list)):
numpy_result = numpy_result,

assert len(cupy_result) == len(numpy_result)

# Check types
cupy_numpy_result_ndarrays = [
_convert_output_to_ndarray(
cupy_r, numpy_r, sp_name, check_sparse_format)
for cupy_r, numpy_r in zip(cupy_result, numpy_result)]

# Check dtypes
if type_check:
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
if cupy_r.dtype != numpy_r.dtype:
raise AssertionError(
'''ndarrays of different dtypes are returned.
cupy: {}
numpy: {}'''.format(cupy_r.dtype, numpy_r.dtype))

# Check contiguities
if contiguous_check:
for cupy_r, numpy_r in zip(cupy_result, numpy_result):
if isinstance(numpy_r, numpy.ndarray):
if (numpy_r.flags.c_contiguous
and not cupy_r.flags.c_contiguous):
raise AssertionError(
'The state of c_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.c_contiguous,
numpy_r.flags.c_contiguous))
if (numpy_r.flags.f_contiguous
and not cupy_r.flags.f_contiguous):
raise AssertionError(
'The state of f_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.f_contiguous,
numpy_r.flags.f_contiguous))

# Check shapes
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
assert cupy_r.shape == numpy_r.shape

# Check item values
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
# Behavior of assigning a negative value to an unsigned integer
# variable is undefined.
# nVidia GPUs and Intel CPUs behave differently.
# To avoid this difference, we need to ignore dimensions whose
# values are negative.

skip = False
if (_contains_signed_and_unsigned(kw)
and cupy_r.dtype in _unsigned_dtypes):
mask = _make_positive_mask(
self, impl, args, kw, name, sp_name, scipy_name)
if cupy_r.shape == ():
skip = (mask == 0).all()
else:
cupy_r = cupy_r[mask].get()
numpy_r = numpy_r[mask]

if not skip:
> check_func(cupy_r, numpy_r)

cupy/testing/_helper.py:343:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 6., 10., 10., 3., 9.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.]])
desired = array([[ 0., 10., 10., 1., 8.],
[ 7., 6., 2., 2., 2.],
[ 1., 10., 10., 2., 9.],
[ 4., 5., 9., 1., 6.]])
rtol = 1e-05, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-05, atol=1e-05
E
E Mismatched elements: 18 / 20 (90%)
E Max absolute difference: 10.
E Max relative difference: 2.
E x: array([[ 6., 10., 10., 3., 9.],
E [ 0., 0., 0., 0., 0.],
E [ 0., 0., 0., 0., 0.],
E [ 0., 0., 0., 0., 0.]])
E y: array([[ 0., 10., 10., 1., 8.],
E [ 7., 6., 2., 2., 2.],
E [ 1., 10., 10., 2., 9.],
E [ 4., 5., 9., 1., 6.]])

cupy/testing/_array.py:24: AssertionError

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9aa41040> parameter: {..._shape': (2,), 'mode': 'constant', 'offset': 0.3, 'order': 2, 'output': None, 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 5, 8, 0, ..., 1, 1, 1],
[ 2, 0, 6, ..., 1, 1, 1],
[ 4, 255, 0, ..., ..., 1, 1, 1],
[ 1, 1, 1, ..., 1, 1, 1],
[ 1, 1, 1, ..., 1, 1, 1]], dtype=uint8)
desired = array([[5, 8, 0, ..., 1, 1, 1],
[2, 0, 6, ..., 1, 1, 1],
[4, 0, 0, ..., 1, 1, 1],
...,
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 5 / 10000 (0.05%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 5, 8, 0, ..., 1, 1, 1],
E [ 2, 0, 6, ..., 1, 1, 1],
E [ 4, 255, 0, ..., 1, 1, 1],...
E y: array([[5, 8, 0, ..., 1, 1, 1],
E [2, 0, 6, ..., 1, 1, 1],
E [4, 0, 0, ..., 1, 1, 1],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a9517c0> parameter: {...ape': (2,), 'mode': 'constant', 'offset': 0.3, 'order': 2, 'output': 'empty', 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 5, 8, 0, ..., 1, 1, 1],
[ 2, 0, 6, ..., 1, 1, 1],
[ 4, 255, 0, ..., ..., 1, 1, 1],
[ 1, 1, 1, ..., 1, 1, 1],
[ 1, 1, 1, ..., 1, 1, 1]], dtype=uint8)
desired = array([[5, 8, 0, ..., 1, 1, 1],
[2, 0, 6, ..., 1, 1, 1],
[4, 0, 0, ..., 1, 1, 1],
...,
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 5 / 10000 (0.05%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 5, 8, 0, ..., 1, 1, 1],
E [ 2, 0, 6, ..., 1, 1, 1],
E [ 4, 255, 0, ..., 1, 1, 1],...
E y: array([[5, 8, 0, ..., 1, 1, 1],
E [2, 0, 6, ..., 1, 1, 1],
E [4, 0, 0, ..., 1, 1, 1],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9aa4b850> parameter: {..._shape': (2,), 'mode': 'constant', 'offset': 0.3, 'order': 3, 'output': None, 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 5, 8, 1, ..., 1, 1, 1],
[ 2, 0, 6, ..., 1, 1, 1],
[ 3, 255, 0, ..., ..., 1, 1, 1],
[ 1, 1, 1, ..., 1, 1, 1],
[ 1, 1, 1, ..., 1, 1, 1]], dtype=uint8)
desired = array([[5, 8, 1, ..., 1, 1, 1],
[2, 0, 6, ..., 1, 1, 1],
[3, 0, 0, ..., 1, 1, 1],
...,
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 7 / 10000 (0.07%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 5, 8, 1, ..., 1, 1, 1],
E [ 2, 0, 6, ..., 1, 1, 1],
E [ 3, 255, 0, ..., 1, 1, 1],...
E y: array([[5, 8, 1, ..., 1, 1, 1],
E [2, 0, 6, ..., 1, 1, 1],
E [3, 0, 0, ..., 1, 1, 1],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a998970> parameter: {...ape': (2,), 'mode': 'constant', 'offset': 0.3, 'order': 3, 'output': 'empty', 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 5, 8, 1, ..., 1, 1, 1],
[ 2, 0, 6, ..., 1, 1, 1],
[ 3, 255, 0, ..., ..., 1, 1, 1],
[ 1, 1, 1, ..., 1, 1, 1],
[ 1, 1, 1, ..., 1, 1, 1]], dtype=uint8)
desired = array([[5, 8, 1, ..., 1, 1, 1],
[2, 0, 6, ..., 1, 1, 1],
[3, 0, 0, ..., 1, 1, 1],
...,
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 7 / 10000 (0.07%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 5, 8, 1, ..., 1, 1, 1],
E [ 2, 0, 6, ..., 1, 1, 1],
E [ 3, 255, 0, ..., 1, 1, 1],...
E y: array([[5, 8, 1, ..., 1, 1, 1],
E [2, 0, 6, ..., 1, 1, 1],
E [3, 0, 0, ..., 1, 1, 1],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a9514f0> parameter: {..._shape': (2,), 'mode': 'constant', 'offset': 0.3, 'order': 4, 'output': None, 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 5, 8, 0, ..., 1, 1, 1],
[ 2, 0, 6, ..., 1, 1, 1],
[ 3, 255, 0, ..., ..., 1, 1, 1],
[ 1, 1, 1, ..., 1, 1, 1],
[ 1, 1, 1, ..., 1, 1, 1]], dtype=uint8)
desired = array([[5, 8, 0, ..., 1, 1, 1],
[2, 0, 6, ..., 1, 1, 1],
[3, 0, 0, ..., 1, 1, 1],
...,
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 9 / 10000 (0.09%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 5, 8, 0, ..., 1, 1, 1],
E [ 2, 0, 6, ..., 1, 1, 1],
E [ 3, 255, 0, ..., 1, 1, 1],...
E y: array([[5, 8, 0, ..., 1, 1, 1],
E [2, 0, 6, ..., 1, 1, 1],
E [3, 0, 0, ..., 1, 1, 1],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a908c10> parameter: {...ape': (2,), 'mode': 'constant', 'offset': 0.3, 'order': 4, 'output': 'empty', 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 5, 8, 0, ..., 1, 1, 1],
[ 2, 0, 6, ..., 1, 1, 1],
[ 3, 255, 0, ..., ..., 1, 1, 1],
[ 1, 1, 1, ..., 1, 1, 1],
[ 1, 1, 1, ..., 1, 1, 1]], dtype=uint8)
desired = array([[5, 8, 0, ..., 1, 1, 1],
[2, 0, 6, ..., 1, 1, 1],
[3, 0, 0, ..., 1, 1, 1],
...,
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 9 / 10000 (0.09%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 5, 8, 0, ..., 1, 1, 1],
E [ 2, 0, 6, ..., 1, 1, 1],
E [ 3, 255, 0, ..., 1, 1, 1],...
E y: array([[5, 8, 0, ..., 1, 1, 1],
E [2, 0, 6, ..., 1, 1, 1],
E [3, 0, 0, ..., 1, 1, 1],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9aa5aa90> parameter: {..._shape': (2,), 'mode': 'constant', 'offset': 0.3, 'order': 5, 'output': None, 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 5, 9, 0, ..., 1, 1, 1],
[ 2, 0, 6, ..., 1, 1, 1],
[ 3, 255, 0, ..., ..., 1, 1, 1],
[ 1, 1, 1, ..., 1, 1, 1],
[ 1, 1, 1, ..., 1, 1, 1]], dtype=uint8)
desired = array([[5, 9, 0, ..., 1, 1, 1],
[2, 0, 6, ..., 1, 1, 1],
[3, 0, 0, ..., 1, 1, 1],
...,
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 9 / 10000 (0.09%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 5, 9, 0, ..., 1, 1, 1],
E [ 2, 0, 6, ..., 1, 1, 1],
E [ 3, 255, 0, ..., 1, 1, 1],...
E y: array([[5, 9, 0, ..., 1, 1, 1],
E [2, 0, 6, ..., 1, 1, 1],
E [3, 0, 0, ..., 1, 1, 1],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a7d2eb0> parameter: {...ape': (2,), 'mode': 'constant', 'offset': 0.3, 'order': 5, 'output': 'empty', 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 5, 9, 0, ..., 1, 1, 1],
[ 2, 0, 6, ..., 1, 1, 1],
[ 3, 255, 0, ..., ..., 1, 1, 1],
[ 1, 1, 1, ..., 1, 1, 1],
[ 1, 1, 1, ..., 1, 1, 1]], dtype=uint8)
desired = array([[5, 9, 0, ..., 1, 1, 1],
[2, 0, 6, ..., 1, 1, 1],
[3, 0, 0, ..., 1, 1, 1],
...,
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 9 / 10000 (0.09%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 5, 9, 0, ..., 1, 1, 1],
E [ 2, 0, 6, ..., 1, 1, 1],
E [ 3, 255, 0, ..., 1, 1, 1],...
E y: array([[5, 9, 0, ..., 1, 1, 1],
E [2, 0, 6, ..., 1, 1, 1],
E [3, 0, 0, ..., 1, 1, 1],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9aa6d910> parameter: {... (2,), 'mode': 'constant', 'offset': [-1.3, 1.3], 'order': 2, 'output': None, 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[1, 1, 1, ..., 1, 1, 1],
[7, 5, 1, ..., 1, 1, 1],
[4, 2, 3, ..., 1, 1, 1],
...,
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1]], dtype=uint8)
desired = array([[1, 1, 1, ..., 1, 1, 1],
[7, 5, 1, ..., 1, 1, 1],
[4, 2, 3, ..., 1, 1, 1],
...,
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 5 / 10000 (0.05%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[1, 1, 1, ..., 1, 1, 1],
E [7, 5, 1, ..., 1, 1, 1],
E [4, 2, 3, ..., 1, 1, 1],...
E y: array([[1, 1, 1, ..., 1, 1, 1],
E [7, 5, 1, ..., 1, 1, 1],
E [4, 2, 3, ..., 1, 1, 1],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a902970> parameter: {...,), 'mode': 'constant', 'offset': [-1.3, 1.3], 'order': 2, 'output': 'empty', 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[1, 1, 1, ..., 1, 1, 1],
[7, 5, 1, ..., 1, 1, 1],
[4, 2, 3, ..., 1, 1, 1],
...,
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1]], dtype=uint8)
desired = array([[1, 1, 1, ..., 1, 1, 1],
[7, 5, 1, ..., 1, 1, 1],
[4, 2, 3, ..., 1, 1, 1],
...,
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 5 / 10000 (0.05%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[1, 1, 1, ..., 1, 1, 1],
E [7, 5, 1, ..., 1, 1, 1],
E [4, 2, 3, ..., 1, 1, 1],...
E y: array([[1, 1, 1, ..., 1, 1, 1],
E [7, 5, 1, ..., 1, 1, 1],
E [4, 2, 3, ..., 1, 1, 1],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9aa5f4f0> parameter: {... (2,), 'mode': 'constant', 'offset': [-1.3, 1.3], 'order': 3, 'output': None, 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[1, 1, 1, ..., 1, 1, 1],
[7, 5, 1, ..., 1, 1, 1],
[4, 2, 3, ..., 1, 1, 1],
...,
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1]], dtype=uint8)
desired = array([[1, 1, 1, ..., 1, 1, 1],
[7, 5, 1, ..., 1, 1, 1],
[4, 2, 3, ..., 1, 1, 1],
...,
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 6 / 10000 (0.06%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[1, 1, 1, ..., 1, 1, 1],
E [7, 5, 1, ..., 1, 1, 1],
E [4, 2, 3, ..., 1, 1, 1],...
E y: array([[1, 1, 1, ..., 1, 1, 1],
E [7, 5, 1, ..., 1, 1, 1],
E [4, 2, 3, ..., 1, 1, 1],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9aa56820> parameter: {...,), 'mode': 'constant', 'offset': [-1.3, 1.3], 'order': 3, 'output': 'empty', 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[1, 1, 1, ..., 1, 1, 1],
[7, 5, 1, ..., 1, 1, 1],
[4, 2, 3, ..., 1, 1, 1],
...,
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1]], dtype=uint8)
desired = array([[1, 1, 1, ..., 1, 1, 1],
[7, 5, 1, ..., 1, 1, 1],
[4, 2, 3, ..., 1, 1, 1],
...,
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 6 / 10000 (0.06%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[1, 1, 1, ..., 1, 1, 1],
E [7, 5, 1, ..., 1, 1, 1],
E [4, 2, 3, ..., 1, 1, 1],...
E y: array([[1, 1, 1, ..., 1, 1, 1],
E [7, 5, 1, ..., 1, 1, 1],
E [4, 2, 3, ..., 1, 1, 1],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a98f310> parameter: {... (2,), 'mode': 'constant', 'offset': [-1.3, 1.3], 'order': 4, 'output': None, 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[1, 1, 1, ..., 1, 1, 1],
[7, 5, 1, ..., 1, 1, 1],
[4, 2, 3, ..., 1, 1, 1],
...,
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1]], dtype=uint8)
desired = array([[1, 1, 1, ..., 1, 1, 1],
[7, 5, 1, ..., 1, 1, 1],
[4, 2, 3, ..., 1, 1, 1],
...,
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 8 / 10000 (0.08%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[1, 1, 1, ..., 1, 1, 1],
E [7, 5, 1, ..., 1, 1, 1],
E [4, 2, 3, ..., 1, 1, 1],...
E y: array([[1, 1, 1, ..., 1, 1, 1],
E [7, 5, 1, ..., 1, 1, 1],
E [4, 2, 3, ..., 1, 1, 1],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a75f310> parameter: {...,), 'mode': 'constant', 'offset': [-1.3, 1.3], 'order': 4, 'output': 'empty', 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[1, 1, 1, ..., 1, 1, 1],
[7, 5, 1, ..., 1, 1, 1],
[4, 2, 3, ..., 1, 1, 1],
...,
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1]], dtype=uint8)
desired = array([[1, 1, 1, ..., 1, 1, 1],
[7, 5, 1, ..., 1, 1, 1],
[4, 2, 3, ..., 1, 1, 1],
...,
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 8 / 10000 (0.08%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[1, 1, 1, ..., 1, 1, 1],
E [7, 5, 1, ..., 1, 1, 1],
E [4, 2, 3, ..., 1, 1, 1],...
E y: array([[1, 1, 1, ..., 1, 1, 1],
E [7, 5, 1, ..., 1, 1, 1],
E [4, 2, 3, ..., 1, 1, 1],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a7d2670> parameter: {... (2,), 'mode': 'constant', 'offset': [-1.3, 1.3], 'order': 5, 'output': None, 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[1, 1, 1, ..., 1, 1, 1],
[7, 5, 1, ..., 1, 1, 1],
[5, 2, 3, ..., 1, 1, 1],
...,
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1]], dtype=uint8)
desired = array([[1, 1, 1, ..., 1, 1, 1],
[7, 5, 1, ..., 1, 1, 1],
[5, 2, 3, ..., 1, 1, 1],
...,
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 9 / 10000 (0.09%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[1, 1, 1, ..., 1, 1, 1],
E [7, 5, 1, ..., 1, 1, 1],
E [5, 2, 3, ..., 1, 1, 1],...
E y: array([[1, 1, 1, ..., 1, 1, 1],
E [7, 5, 1, ..., 1, 1, 1],
E [5, 2, 3, ..., 1, 1, 1],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a951070> parameter: {...,), 'mode': 'constant', 'offset': [-1.3, 1.3], 'order': 5, 'output': 'empty', 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[1, 1, 1, ..., 1, 1, 1],
[7, 5, 1, ..., 1, 1, 1],
[5, 2, 3, ..., 1, 1, 1],
...,
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1]], dtype=uint8)
desired = array([[1, 1, 1, ..., 1, 1, 1],
[7, 5, 1, ..., 1, 1, 1],
[5, 2, 3, ..., 1, 1, 1],
...,
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1],
[1, 1, 1, ..., 1, 1, 1]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 9 / 10000 (0.09%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[1, 1, 1, ..., 1, 1, 1],
E [7, 5, 1, ..., 1, 1, 1],
E [5, 2, 3, ..., 1, 1, 1],...
E y: array([[1, 1, 1, ..., 1, 1, 1],
E [7, 5, 1, ..., 1, 1, 1],
E [5, 2, 3, ..., 1, 1, 1],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9ca659b310> parameter: {...x_shape': (2,), 'mode': 'nearest', 'offset': 0.3, 'order': 2, 'output': None, 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 5, 8, 1, ..., 1, 1, 1],
[ 2, 0, 6, ..., 9, 9, 9],
[ 3, 255, 0, ..., ..., 8, 8, 8],
[ 6, 7, 1, ..., 8, 8, 8],
[ 6, 7, 1, ..., 8, 8, 8]], dtype=uint8)
desired = array([[5, 8, 1, ..., 1, 1, 1],
[2, 0, 6, ..., 9, 9, 9],
[3, 0, 0, ..., 5, 5, 5],
...,
[6, 7, 1, ..., 8, 8, 8],
[6, 7, 1, ..., 8, 8, 8],
[6, 7, 1, ..., 8, 8, 8]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 5 / 10000 (0.05%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 5, 8, 1, ..., 1, 1, 1],
E [ 2, 0, 6, ..., 9, 9, 9],
E [ 3, 255, 0, ..., 5, 5, 5],...
E y: array([[5, 8, 1, ..., 1, 1, 1],
E [2, 0, 6, ..., 9, 9, 9],
E [3, 0, 0, ..., 5, 5, 5],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9d0296aa30> parameter: {...hape': (2,), 'mode': 'nearest', 'offset': 0.3, 'order': 2, 'output': 'empty', 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 5, 8, 1, ..., 1, 1, 1],
[ 2, 0, 6, ..., 9, 9, 9],
[ 3, 255, 0, ..., ..., 8, 8, 8],
[ 6, 7, 1, ..., 8, 8, 8],
[ 6, 7, 1, ..., 8, 8, 8]], dtype=uint8)
desired = array([[5, 8, 1, ..., 1, 1, 1],
[2, 0, 6, ..., 9, 9, 9],
[3, 0, 0, ..., 5, 5, 5],
...,
[6, 7, 1, ..., 8, 8, 8],
[6, 7, 1, ..., 8, 8, 8],
[6, 7, 1, ..., 8, 8, 8]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 5 / 10000 (0.05%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 5, 8, 1, ..., 1, 1, 1],
E [ 2, 0, 6, ..., 9, 9, 9],
E [ 3, 255, 0, ..., 5, 5, 5],...
E y: array([[5, 8, 1, ..., 1, 1, 1],
E [2, 0, 6, ..., 9, 9, 9],
E [3, 0, 0, ..., 5, 5, 5],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9cfaa0a580> parameter: {...x_shape': (2,), 'mode': 'nearest', 'offset': 0.3, 'order': 3, 'output': None, 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 5, 8, 2, ..., 1, 1, 1],
[ 2, 0, 6, ..., 9, 9, 9],
[ 3, 255, 0, ..., ..., 8, 8, 8],
[ 6, 7, 1, ..., 8, 8, 8],
[ 6, 7, 1, ..., 8, 8, 8]], dtype=uint8)
desired = array([[5, 8, 2, ..., 1, 1, 1],
[2, 0, 6, ..., 9, 9, 9],
[3, 0, 0, ..., 5, 5, 5],
...,
[6, 7, 1, ..., 8, 8, 8],
[6, 7, 1, ..., 8, 8, 8],
[6, 7, 1, ..., 8, 8, 8]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 7 / 10000 (0.07%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 5, 8, 2, ..., 1, 1, 1],
E [ 2, 0, 6, ..., 9, 9, 9],
E [ 3, 255, 0, ..., 5, 5, 5],...
E y: array([[5, 8, 2, ..., 1, 1, 1],
E [2, 0, 6, ..., 9, 9, 9],
E [3, 0, 0, ..., 5, 5, 5],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9cfaa0a850> parameter: {...hape': (2,), 'mode': 'nearest', 'offset': 0.3, 'order': 3, 'output': 'empty', 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 5, 8, 2, ..., 1, 1, 1],
[ 2, 0, 6, ..., 9, 9, 9],
[ 3, 255, 0, ..., ..., 8, 8, 8],
[ 6, 7, 1, ..., 8, 8, 8],
[ 6, 7, 1, ..., 8, 8, 8]], dtype=uint8)
desired = array([[5, 8, 2, ..., 1, 1, 1],
[2, 0, 6, ..., 9, 9, 9],
[3, 0, 0, ..., 5, 5, 5],
...,
[6, 7, 1, ..., 8, 8, 8],
[6, 7, 1, ..., 8, 8, 8],
[6, 7, 1, ..., 8, 8, 8]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 7 / 10000 (0.07%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 5, 8, 2, ..., 1, 1, 1],
E [ 2, 0, 6, ..., 9, 9, 9],
E [ 3, 255, 0, ..., 5, 5, 5],...
E y: array([[5, 8, 2, ..., 1, 1, 1],
E [2, 0, 6, ..., 9, 9, 9],
E [3, 0, 0, ..., 5, 5, 5],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9cfeea16d0> parameter: {...x_shape': (2,), 'mode': 'nearest', 'offset': 0.3, 'order': 4, 'output': None, 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 6, 8, 2, ..., 0, 0, 0],
[ 2, 0, 6, ..., 9, 9, 9],
[ 3, 255, 0, ..., ..., 8, 8, 8],
[ 6, 7, 1, ..., 8, 8, 8],
[ 6, 7, 1, ..., 8, 8, 8]], dtype=uint8)
desired = array([[6, 8, 2, ..., 0, 0, 0],
[2, 0, 6, ..., 9, 9, 9],
[3, 0, 0, ..., 5, 5, 5],
...,
[6, 7, 1, ..., 8, 8, 8],
[6, 7, 1, ..., 8, 8, 8],
[6, 7, 1, ..., 8, 8, 8]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 9 / 10000 (0.09%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 6, 8, 2, ..., 0, 0, 0],
E [ 2, 0, 6, ..., 9, 9, 9],
E [ 3, 255, 0, ..., 5, 5, 5],...
E y: array([[6, 8, 2, ..., 0, 0, 0],
E [2, 0, 6, ..., 9, 9, 9],
E [3, 0, 0, ..., 5, 5, 5],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9aa78a60> parameter: {...hape': (2,), 'mode': 'nearest', 'offset': 0.3, 'order': 4, 'output': 'empty', 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 6, 8, 2, ..., 0, 0, 0],
[ 2, 0, 6, ..., 9, 9, 9],
[ 3, 255, 0, ..., ..., 8, 8, 8],
[ 6, 7, 1, ..., 8, 8, 8],
[ 6, 7, 1, ..., 8, 8, 8]], dtype=uint8)
desired = array([[6, 8, 2, ..., 0, 0, 0],
[2, 0, 6, ..., 9, 9, 9],
[3, 0, 0, ..., 5, 5, 5],
...,
[6, 7, 1, ..., 8, 8, 8],
[6, 7, 1, ..., 8, 8, 8],
[6, 7, 1, ..., 8, 8, 8]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 9 / 10000 (0.09%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 6, 8, 2, ..., 0, 0, 0],
E [ 2, 0, 6, ..., 9, 9, 9],
E [ 3, 255, 0, ..., 5, 5, 5],...
E y: array([[6, 8, 2, ..., 0, 0, 0],
E [2, 0, 6, ..., 9, 9, 9],
E [3, 0, 0, ..., 5, 5, 5],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a7ad5e0> parameter: {...x_shape': (2,), 'mode': 'nearest', 'offset': 0.3, 'order': 5, 'output': None, 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 6, 8, 2, ..., 0, 0, 0],
[ 2, 0, 6, ..., 9, 9, 9],
[ 3, 255, 0, ..., ..., 8, 8, 8],
[ 6, 7, 1, ..., 8, 8, 8],
[ 6, 7, 1, ..., 8, 8, 8]], dtype=uint8)
desired = array([[6, 8, 2, ..., 0, 0, 0],
[2, 0, 6, ..., 9, 9, 9],
[3, 0, 0, ..., 5, 5, 5],
...,
[6, 7, 1, ..., 8, 8, 8],
[6, 7, 1, ..., 8, 8, 8],
[6, 7, 1, ..., 8, 8, 8]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 89 / 10000 (0.89%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 6, 8, 2, ..., 0, 0, 0],
E [ 2, 0, 6, ..., 9, 9, 9],
E [ 3, 255, 0, ..., 5, 5, 5],...
E y: array([[6, 8, 2, ..., 0, 0, 0],
E [2, 0, 6, ..., 9, 9, 9],
E [3, 0, 0, ..., 5, 5, 5],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a8f9fa0> parameter: {...hape': (2,), 'mode': 'nearest', 'offset': 0.3, 'order': 5, 'output': 'empty', 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 6, 8, 2, ..., 0, 0, 0],
[ 2, 0, 6, ..., 9, 9, 9],
[ 3, 255, 0, ..., ..., 8, 8, 8],
[ 6, 7, 1, ..., 8, 8, 8],
[ 6, 7, 1, ..., 8, 8, 8]], dtype=uint8)
desired = array([[6, 8, 2, ..., 0, 0, 0],
[2, 0, 6, ..., 9, 9, 9],
[3, 0, 0, ..., 5, 5, 5],
...,
[6, 7, 1, ..., 8, 8, 8],
[6, 7, 1, ..., 8, 8, 8],
[6, 7, 1, ..., 8, 8, 8]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 89 / 10000 (0.89%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 6, 8, 2, ..., 0, 0, 0],
E [ 2, 0, 6, ..., 9, 9, 9],
E [ 3, 255, 0, ..., 5, 5, 5],...
E y: array([[6, 8, 2, ..., 0, 0, 0],
E [2, 0, 6, ..., 9, 9, 9],
E [3, 0, 0, ..., 5, 5, 5],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a99b310> parameter: {...: (2,), 'mode': 'nearest', 'offset': [-1.3, 1.3], 'order': 2, 'output': None, 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[7, 7, 0, ..., 0, 0, 0],
[7, 5, 1, ..., 3, 3, 3],
[4, 2, 3, ..., 6, 6, 6],
...,
[1, 7, 3, ..., 8, 8, 8],
[1, 7, 3, ..., 8, 8, 8],
[1, 7, 3, ..., 8, 8, 8]], dtype=uint8)
desired = array([[7, 7, 0, ..., 0, 0, 0],
[7, 5, 1, ..., 3, 3, 3],
[4, 2, 3, ..., 6, 6, 6],
...,
[1, 7, 3, ..., 8, 8, 8],
[1, 7, 3, ..., 8, 8, 8],
[1, 7, 3, ..., 8, 8, 8]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 6 / 10000 (0.06%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[7, 7, 0, ..., 0, 0, 0],
E [7, 5, 1, ..., 3, 3, 3],
E [4, 2, 3, ..., 6, 6, 6],...
E y: array([[7, 7, 0, ..., 0, 0, 0],
E [7, 5, 1, ..., 3, 3, 3],
E [4, 2, 3, ..., 6, 6, 6],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a792550> parameter: {...2,), 'mode': 'nearest', 'offset': [-1.3, 1.3], 'order': 2, 'output': 'empty', 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[7, 7, 0, ..., 0, 0, 0],
[7, 5, 1, ..., 3, 3, 3],
[4, 2, 3, ..., 6, 6, 6],
...,
[1, 7, 3, ..., 8, 8, 8],
[1, 7, 3, ..., 8, 8, 8],
[1, 7, 3, ..., 8, 8, 8]], dtype=uint8)
desired = array([[7, 7, 0, ..., 0, 0, 0],
[7, 5, 1, ..., 3, 3, 3],
[4, 2, 3, ..., 6, 6, 6],
...,
[1, 7, 3, ..., 8, 8, 8],
[1, 7, 3, ..., 8, 8, 8],
[1, 7, 3, ..., 8, 8, 8]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 6 / 10000 (0.06%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[7, 7, 0, ..., 0, 0, 0],
E [7, 5, 1, ..., 3, 3, 3],
E [4, 2, 3, ..., 6, 6, 6],...
E y: array([[7, 7, 0, ..., 0, 0, 0],
E [7, 5, 1, ..., 3, 3, 3],
E [4, 2, 3, ..., 6, 6, 6],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a992040> parameter: {...: (2,), 'mode': 'nearest', 'offset': [-1.3, 1.3], 'order': 3, 'output': None, 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[7, 7, 0, ..., 0, 0, 0],
[7, 5, 1, ..., 3, 3, 3],
[4, 2, 3, ..., 6, 6, 6],
...,
[1, 7, 3, ..., 8, 8, 8],
[1, 7, 3, ..., 8, 8, 8],
[1, 7, 3, ..., 8, 8, 8]], dtype=uint8)
desired = array([[7, 7, 0, ..., 0, 0, 0],
[7, 5, 1, ..., 3, 3, 3],
[4, 2, 3, ..., 6, 6, 6],
...,
[1, 7, 3, ..., 8, 8, 8],
[1, 7, 3, ..., 8, 8, 8],
[1, 7, 3, ..., 8, 8, 8]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 7 / 10000 (0.07%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[7, 7, 0, ..., 0, 0, 0],
E [7, 5, 1, ..., 3, 3, 3],
E [4, 2, 3, ..., 6, 6, 6],...
E y: array([[7, 7, 0, ..., 0, 0, 0],
E [7, 5, 1, ..., 3, 3, 3],
E [4, 2, 3, ..., 6, 6, 6],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a792ca0> parameter: {...2,), 'mode': 'nearest', 'offset': [-1.3, 1.3], 'order': 3, 'output': 'empty', 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[7, 7, 0, ..., 0, 0, 0],
[7, 5, 1, ..., 3, 3, 3],
[4, 2, 3, ..., 6, 6, 6],
...,
[1, 7, 3, ..., 8, 8, 8],
[1, 7, 3, ..., 8, 8, 8],
[1, 7, 3, ..., 8, 8, 8]], dtype=uint8)
desired = array([[7, 7, 0, ..., 0, 0, 0],
[7, 5, 1, ..., 3, 3, 3],
[4, 2, 3, ..., 6, 6, 6],
...,
[1, 7, 3, ..., 8, 8, 8],
[1, 7, 3, ..., 8, 8, 8],
[1, 7, 3, ..., 8, 8, 8]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 7 / 10000 (0.07%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[7, 7, 0, ..., 0, 0, 0],
E [7, 5, 1, ..., 3, 3, 3],
E [4, 2, 3, ..., 6, 6, 6],...
E y: array([[7, 7, 0, ..., 0, 0, 0],
E [7, 5, 1, ..., 3, 3, 3],
E [4, 2, 3, ..., 6, 6, 6],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a992d90> parameter: {...: (2,), 'mode': 'nearest', 'offset': [-1.3, 1.3], 'order': 4, 'output': None, 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[7, 7, 0, ..., 0, 0, 0],
[7, 5, 1, ..., 3, 3, 3],
[5, 2, 3, ..., 6, 6, 6],
...,
[1, 7, 3, ..., 8, 8, 8],
[1, 7, 3, ..., 8, 8, 8],
[1, 7, 3, ..., 8, 8, 8]], dtype=uint8)
desired = array([[7, 7, 0, ..., 0, 0, 0],
[7, 5, 1, ..., 3, 3, 3],
[5, 2, 3, ..., 6, 6, 6],
...,
[1, 7, 3, ..., 8, 8, 8],
[1, 7, 3, ..., 8, 8, 8],
[1, 7, 3, ..., 8, 8, 8]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 9 / 10000 (0.09%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[7, 7, 0, ..., 0, 0, 0],
E [7, 5, 1, ..., 3, 3, 3],
E [5, 2, 3, ..., 6, 6, 6],...
E y: array([[7, 7, 0, ..., 0, 0, 0],
E [7, 5, 1, ..., 3, 3, 3],
E [5, 2, 3, ..., 6, 6, 6],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a9aebe0> parameter: {...2,), 'mode': 'nearest', 'offset': [-1.3, 1.3], 'order': 4, 'output': 'empty', 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[7, 7, 0, ..., 0, 0, 0],
[7, 5, 1, ..., 3, 3, 3],
[5, 2, 3, ..., 6, 6, 6],
...,
[1, 7, 3, ..., 8, 8, 8],
[1, 7, 3, ..., 8, 8, 8],
[1, 7, 3, ..., 8, 8, 8]], dtype=uint8)
desired = array([[7, 7, 0, ..., 0, 0, 0],
[7, 5, 1, ..., 3, 3, 3],
[5, 2, 3, ..., 6, 6, 6],
...,
[1, 7, 3, ..., 8, 8, 8],
[1, 7, 3, ..., 8, 8, 8],
[1, 7, 3, ..., 8, 8, 8]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 9 / 10000 (0.09%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[7, 7, 0, ..., 0, 0, 0],
E [7, 5, 1, ..., 3, 3, 3],
E [5, 2, 3, ..., 6, 6, 6],...
E y: array([[7, 7, 0, ..., 0, 0, 0],
E [7, 5, 1, ..., 3, 3, 3],
E [5, 2, 3, ..., 6, 6, 6],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a9a5040> parameter: {...: (2,), 'mode': 'nearest', 'offset': [-1.3, 1.3], 'order': 5, 'output': None, 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[7, 7, 0, ..., 0, 0, 0],
[7, 5, 1, ..., 3, 3, 3],
[5, 2, 3, ..., 6, 6, 6],
...,
[1, 7, 3, ..., 8, 8, 8],
[1, 7, 3, ..., 8, 8, 8],
[1, 7, 3, ..., 8, 8, 8]], dtype=uint8)
desired = array([[7, 7, 0, ..., 0, 0, 0],
[7, 5, 1, ..., 3, 3, 3],
[5, 2, 3, ..., 6, 6, 6],
...,
[1, 7, 3, ..., 8, 8, 8],
[1, 7, 3, ..., 8, 8, 8],
[1, 7, 3, ..., 8, 8, 8]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 10 / 10000 (0.1%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[7, 7, 0, ..., 0, 0, 0],
E [7, 5, 1, ..., 3, 3, 3],
E [5, 2, 3, ..., 6, 6, 6],...
E y: array([[7, 7, 0, ..., 0, 0, 0],
E [7, 5, 1, ..., 3, 3, 3],
E [5, 2, 3, ..., 6, 6, 6],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a76cbb0> parameter: {...2,), 'mode': 'nearest', 'offset': [-1.3, 1.3], 'order': 5, 'output': 'empty', 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[7, 7, 0, ..., 0, 0, 0],
[7, 5, 1, ..., 3, 3, 3],
[5, 2, 3, ..., 6, 6, 6],
...,
[1, 7, 3, ..., 8, 8, 8],
[1, 7, 3, ..., 8, 8, 8],
[1, 7, 3, ..., 8, 8, 8]], dtype=uint8)
desired = array([[7, 7, 0, ..., 0, 0, 0],
[7, 5, 1, ..., 3, 3, 3],
[5, 2, 3, ..., 6, 6, 6],
...,
[1, 7, 3, ..., 8, 8, 8],
[1, 7, 3, ..., 8, 8, 8],
[1, 7, 3, ..., 8, 8, 8]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 10 / 10000 (0.1%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[7, 7, 0, ..., 0, 0, 0],
E [7, 5, 1, ..., 3, 3, 3],
E [5, 2, 3, ..., 6, 6, 6],...
E y: array([[7, 7, 0, ..., 0, 0, 0],
E [7, 5, 1, ..., 3, 3, 3],
E [5, 2, 3, ..., 6, 6, 6],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a775040> parameter: {...ix_shape': (2,), 'mode': 'mirror', 'offset': 0.3, 'order': 2, 'output': None, 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 5, 8, 0, ..., 3, 2, 2],
[ 2, 0, 6, ..., 2, 5, 8],
[ 4, 255, 0, ..., ..., 1, 4, 8],
[ 2, 5, 0, ..., 8, 2, 1],
[ 6, 7, 1, ..., 5, 2, 6]], dtype=uint8)
desired = array([[5, 8, 0, ..., 3, 2, 2],
[2, 0, 6, ..., 2, 5, 8],
[4, 0, 0, ..., 4, 7, 4],
...,
[3, 2, 3, ..., 1, 4, 8],
[2, 5, 0, ..., 8, 2, 1],
[6, 7, 1, ..., 5, 2, 6]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 72 / 10000 (0.72%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 5, 8, 0, ..., 3, 2, 2],
E [ 2, 0, 6, ..., 2, 5, 8],
E [ 4, 255, 0, ..., 4, 7, 4],...
E y: array([[5, 8, 0, ..., 3, 2, 2],
E [2, 0, 6, ..., 2, 5, 8],
E [4, 0, 0, ..., 4, 7, 4],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a9660d0> parameter: {...shape': (2,), 'mode': 'mirror', 'offset': 0.3, 'order': 2, 'output': 'empty', 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 5, 8, 0, ..., 3, 2, 2],
[ 2, 0, 6, ..., 2, 5, 8],
[ 4, 255, 0, ..., ..., 1, 4, 8],
[ 2, 5, 0, ..., 8, 2, 1],
[ 6, 7, 1, ..., 5, 2, 6]], dtype=uint8)
desired = array([[5, 8, 0, ..., 3, 2, 2],
[2, 0, 6, ..., 2, 5, 8],
[4, 0, 0, ..., 4, 7, 4],
...,
[3, 2, 3, ..., 1, 4, 8],
[2, 5, 0, ..., 8, 2, 1],
[6, 7, 1, ..., 5, 2, 6]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 72 / 10000 (0.72%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 5, 8, 0, ..., 3, 2, 2],
E [ 2, 0, 6, ..., 2, 5, 8],
E [ 4, 255, 0, ..., 4, 7, 4],...
E y: array([[5, 8, 0, ..., 3, 2, 2],
E [2, 0, 6, ..., 2, 5, 8],
E [4, 0, 0, ..., 4, 7, 4],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a7586d0> parameter: {...ix_shape': (2,), 'mode': 'mirror', 'offset': 0.3, 'order': 3, 'output': None, 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 5, 8, 1, ..., 3, 2, 2],
[ 2, 0, 6, ..., 3, 6, 8],
[ 3, 255, 0, ..., ..., 1, 4, 8],
[ 2, 5, 0, ..., 7, 2, 1],
[ 6, 7, 1, ..., 5, 2, 6]], dtype=uint8)
desired = array([[5, 8, 1, ..., 3, 2, 2],
[2, 0, 6, ..., 3, 6, 8],
[3, 0, 0, ..., 4, 7, 4],
...,
[3, 2, 3, ..., 1, 4, 8],
[2, 5, 0, ..., 7, 2, 1],
[6, 7, 1, ..., 5, 2, 6]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 104 / 10000 (1.04%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 5, 8, 1, ..., 3, 2, 2],
E [ 2, 0, 6, ..., 3, 6, 8],
E [ 3, 255, 0, ..., 4, 7, 4],...
E y: array([[5, 8, 1, ..., 3, 2, 2],
E [2, 0, 6, ..., 3, 6, 8],
E [3, 0, 0, ..., 4, 7, 4],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a760430> parameter: {...shape': (2,), 'mode': 'mirror', 'offset': 0.3, 'order': 3, 'output': 'empty', 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 5, 8, 1, ..., 3, 2, 2],
[ 2, 0, 6, ..., 3, 6, 8],
[ 3, 255, 0, ..., ..., 1, 4, 8],
[ 2, 5, 0, ..., 7, 2, 1],
[ 6, 7, 1, ..., 5, 2, 6]], dtype=uint8)
desired = array([[5, 8, 1, ..., 3, 2, 2],
[2, 0, 6, ..., 3, 6, 8],
[3, 0, 0, ..., 4, 7, 4],
...,
[3, 2, 3, ..., 1, 4, 8],
[2, 5, 0, ..., 7, 2, 1],
[6, 7, 1, ..., 5, 2, 6]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 104 / 10000 (1.04%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 5, 8, 1, ..., 3, 2, 2],
E [ 2, 0, 6, ..., 3, 6, 8],
E [ 3, 255, 0, ..., 4, 7, 4],...
E y: array([[5, 8, 1, ..., 3, 2, 2],
E [2, 0, 6, ..., 3, 6, 8],
E [3, 0, 0, ..., 4, 7, 4],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a95a130> parameter: {...ix_shape': (2,), 'mode': 'mirror', 'offset': 0.3, 'order': 4, 'output': None, 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 5, 8, 0, ..., 4, 2, 2],
[ 2, 0, 6, ..., 3, 6, 8],
[ 3, 255, 0, ..., ..., 0, 4, 8],
[ 2, 5, 255, ..., 7, 2, 0],
[ 6, 7, 1, ..., 5, 2, 6]], dtype=uint8)
desired = array([[5, 8, 0, ..., 4, 2, 2],
[2, 0, 6, ..., 3, 6, 8],
[3, 0, 0, ..., 4, 7, 4],
...,
[3, 2, 3, ..., 0, 4, 8],
[2, 5, 0, ..., 7, 2, 0],
[6, 7, 1, ..., 5, 2, 6]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 163 / 10000 (1.63%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 5, 8, 0, ..., 4, 2, 2],
E [ 2, 0, 6, ..., 3, 6, 8],
E [ 3, 255, 0, ..., 4, 7, 4],...
E y: array([[5, 8, 0, ..., 4, 2, 2],
E [2, 0, 6, ..., 3, 6, 8],
E [3, 0, 0, ..., 4, 7, 4],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a966940> parameter: {...shape': (2,), 'mode': 'mirror', 'offset': 0.3, 'order': 4, 'output': 'empty', 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 5, 8, 0, ..., 4, 2, 2],
[ 2, 0, 6, ..., 3, 6, 8],
[ 3, 255, 0, ..., ..., 0, 4, 8],
[ 2, 5, 255, ..., 7, 2, 0],
[ 6, 7, 1, ..., 5, 2, 6]], dtype=uint8)
desired = array([[5, 8, 0, ..., 4, 2, 2],
[2, 0, 6, ..., 3, 6, 8],
[3, 0, 0, ..., 4, 7, 4],
...,
[3, 2, 3, ..., 0, 4, 8],
[2, 5, 0, ..., 7, 2, 0],
[6, 7, 1, ..., 5, 2, 6]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 163 / 10000 (1.63%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 5, 8, 0, ..., 4, 2, 2],
E [ 2, 0, 6, ..., 3, 6, 8],
E [ 3, 255, 0, ..., 4, 7, 4],...
E y: array([[5, 8, 0, ..., 4, 2, 2],
E [2, 0, 6, ..., 3, 6, 8],
E [3, 0, 0, ..., 4, 7, 4],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9aa539a0> parameter: {...ix_shape': (2,), 'mode': 'mirror', 'offset': 0.3, 'order': 5, 'output': None, 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 5, 9, 0, ..., 4, 2, 2],
[ 2, 0, 6, ..., 3, 6, 8],
[ 3, 255, 0, ..., ..., 0, 4, 8],
[ 2, 5, 255, ..., 7, 2, 0],
[ 6, 7, 1, ..., 5, 2, 6]], dtype=uint8)
desired = array([[5, 9, 0, ..., 4, 2, 2],
[2, 0, 6, ..., 3, 6, 8],
[3, 0, 0, ..., 4, 7, 4],
...,
[3, 2, 2, ..., 0, 4, 8],
[2, 5, 0, ..., 7, 2, 0],
[6, 7, 1, ..., 5, 2, 6]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 191 / 10000 (1.91%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 5, 9, 0, ..., 4, 2, 2],
E [ 2, 0, 6, ..., 3, 6, 8],
E [ 3, 255, 0, ..., 4, 7, 4],...
E y: array([[5, 9, 0, ..., 4, 2, 2],
E [2, 0, 6, ..., 3, 6, 8],
E [3, 0, 0, ..., 4, 7, 4],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a9423d0> parameter: {...shape': (2,), 'mode': 'mirror', 'offset': 0.3, 'order': 5, 'output': 'empty', 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 5, 9, 0, ..., 4, 2, 2],
[ 2, 0, 6, ..., 3, 6, 8],
[ 3, 255, 0, ..., ..., 0, 4, 8],
[ 2, 5, 255, ..., 7, 2, 0],
[ 6, 7, 1, ..., 5, 2, 6]], dtype=uint8)
desired = array([[5, 9, 0, ..., 4, 2, 2],
[2, 0, 6, ..., 3, 6, 8],
[3, 0, 0, ..., 4, 7, 4],
...,
[3, 2, 2, ..., 0, 4, 8],
[2, 5, 0, ..., 7, 2, 0],
[6, 7, 1, ..., 5, 2, 6]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 191 / 10000 (1.91%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 5, 9, 0, ..., 4, 2, 2],
E [ 2, 0, 6, ..., 3, 6, 8],
E [ 3, 255, 0, ..., 4, 7, 4],...
E y: array([[5, 9, 0, ..., 4, 2, 2],
E [2, 0, 6, ..., 3, 6, 8],
E [3, 0, 0, ..., 4, 7, 4],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a917bb0> parameter: {...': (2,), 'mode': 'mirror', 'offset': [-1.3, 1.3], 'order': 2, 'output': None, 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 3, 4, 5, ..., 6, 8, 2],
[ 7, 5, 1, ..., 5, 5, 1],
[ 4, 2, 3, ..., 10, 6, 3],
... 2, 7, 4, ..., 1, 6, 7],
[ 4, 5, 8, ..., 3, 1, 2],
[ 8, 5, 1, ..., 3, 4, 10]], dtype=uint8)
desired = array([[ 3, 4, 5, ..., 6, 8, 2],
[ 7, 5, 1, ..., 5, 5, 1],
[ 4, 2, 3, ..., 10, 6, 3],
... 2, 7, 4, ..., 1, 6, 7],
[ 4, 5, 8, ..., 3, 1, 2],
[ 8, 5, 1, ..., 3, 4, 10]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 63 / 10000 (0.63%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 3, 4, 5, ..., 6, 8, 2],
E [ 7, 5, 1, ..., 5, 5, 1],
E [ 4, 2, 3, ..., 10, 6, 3],...
E y: array([[ 3, 4, 5, ..., 6, 8, 2],
E [ 7, 5, 1, ..., 5, 5, 1],
E [ 4, 2, 3, ..., 10, 6, 3],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9ca6da3ee0> parameter: {...(2,), 'mode': 'mirror', 'offset': [-1.3, 1.3], 'order': 2, 'output': 'empty', 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 3, 4, 5, ..., 6, 8, 2],
[ 7, 5, 1, ..., 5, 5, 1],
[ 4, 2, 3, ..., 10, 6, 3],
... 2, 7, 4, ..., 1, 6, 7],
[ 4, 5, 8, ..., 3, 1, 2],
[ 8, 5, 1, ..., 3, 4, 10]], dtype=uint8)
desired = array([[ 3, 4, 5, ..., 6, 8, 2],
[ 7, 5, 1, ..., 5, 5, 1],
[ 4, 2, 3, ..., 10, 6, 3],
... 2, 7, 4, ..., 1, 6, 7],
[ 4, 5, 8, ..., 3, 1, 2],
[ 8, 5, 1, ..., 3, 4, 10]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 63 / 10000 (0.63%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 3, 4, 5, ..., 6, 8, 2],
E [ 7, 5, 1, ..., 5, 5, 1],
E [ 4, 2, 3, ..., 10, 6, 3],...
E y: array([[ 3, 4, 5, ..., 6, 8, 2],
E [ 7, 5, 1, ..., 5, 5, 1],
E [ 4, 2, 3, ..., 10, 6, 3],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a9562b0> parameter: {...': (2,), 'mode': 'mirror', 'offset': [-1.3, 1.3], 'order': 3, 'output': None, 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 3, 4, 5, ..., 6, 7, 2],
[ 7, 5, 1, ..., 5, 5, 1],
[ 4, 2, 3, ..., 10, 6, 3],
... 2, 7, 4, ..., 1, 7, 7],
[ 4, 5, 8, ..., 3, 1, 2],
[ 8, 5, 2, ..., 3, 4, 11]], dtype=uint8)
desired = array([[ 3, 4, 5, ..., 6, 7, 2],
[ 7, 5, 1, ..., 5, 5, 1],
[ 4, 2, 3, ..., 10, 6, 3],
... 2, 7, 4, ..., 1, 7, 7],
[ 4, 5, 8, ..., 3, 1, 2],
[ 8, 5, 2, ..., 3, 4, 11]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 82 / 10000 (0.82%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 3, 4, 5, ..., 6, 7, 2],
E [ 7, 5, 1, ..., 5, 5, 1],
E [ 4, 2, 3, ..., 10, 6, 3],...
E y: array([[ 3, 4, 5, ..., 6, 7, 2],
E [ 7, 5, 1, ..., 5, 5, 1],
E [ 4, 2, 3, ..., 10, 6, 3],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9ca797e3a0> parameter: {...(2,), 'mode': 'mirror', 'offset': [-1.3, 1.3], 'order': 3, 'output': 'empty', 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 3, 4, 5, ..., 6, 7, 2],
[ 7, 5, 1, ..., 5, 5, 1],
[ 4, 2, 3, ..., 10, 6, 3],
... 2, 7, 4, ..., 1, 7, 7],
[ 4, 5, 8, ..., 3, 1, 2],
[ 8, 5, 2, ..., 3, 4, 11]], dtype=uint8)
desired = array([[ 3, 4, 5, ..., 6, 7, 2],
[ 7, 5, 1, ..., 5, 5, 1],
[ 4, 2, 3, ..., 10, 6, 3],
... 2, 7, 4, ..., 1, 7, 7],
[ 4, 5, 8, ..., 3, 1, 2],
[ 8, 5, 2, ..., 3, 4, 11]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 82 / 10000 (0.82%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 3, 4, 5, ..., 6, 7, 2],
E [ 7, 5, 1, ..., 5, 5, 1],
E [ 4, 2, 3, ..., 10, 6, 3],...
E y: array([[ 3, 4, 5, ..., 6, 7, 2],
E [ 7, 5, 1, ..., 5, 5, 1],
E [ 4, 2, 3, ..., 10, 6, 3],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9cfef47100> parameter: {...': (2,), 'mode': 'mirror', 'offset': [-1.3, 1.3], 'order': 4, 'output': None, 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 3, 4, 5, ..., 6, 7, 2],
[ 7, 5, 1, ..., 5, 5, 1],
[ 4, 2, 3, ..., 11, 7, 3],
... 2, 7, 4, ..., 1, 7, 7],
[ 4, 5, 8, ..., 3, 1, 2],
[ 9, 5, 1, ..., 2, 4, 12]], dtype=uint8)
desired = array([[ 3, 4, 5, ..., 6, 7, 2],
[ 7, 5, 1, ..., 5, 5, 1],
[ 4, 2, 3, ..., 11, 7, 3],
... 2, 7, 4, ..., 1, 7, 7],
[ 4, 5, 8, ..., 3, 1, 2],
[ 9, 5, 1, ..., 2, 4, 12]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 144 / 10000 (1.44%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 3, 4, 5, ..., 6, 7, 2],
E [ 7, 5, 1, ..., 5, 5, 1],
E [ 4, 2, 3, ..., 11, 7, 3],...
E y: array([[ 3, 4, 5, ..., 6, 7, 2],
E [ 7, 5, 1, ..., 5, 5, 1],
E [ 4, 2, 3, ..., 11, 7, 3],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9cfef477c0> parameter: {...(2,), 'mode': 'mirror', 'offset': [-1.3, 1.3], 'order': 4, 'output': 'empty', 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 3, 4, 5, ..., 6, 7, 2],
[ 7, 5, 1, ..., 5, 5, 1],
[ 4, 2, 3, ..., 11, 7, 3],
... 2, 7, 4, ..., 1, 7, 7],
[ 4, 5, 8, ..., 3, 1, 2],
[ 9, 5, 1, ..., 2, 4, 12]], dtype=uint8)
desired = array([[ 3, 4, 5, ..., 6, 7, 2],
[ 7, 5, 1, ..., 5, 5, 1],
[ 4, 2, 3, ..., 11, 7, 3],
... 2, 7, 4, ..., 1, 7, 7],
[ 4, 5, 8, ..., 3, 1, 2],
[ 9, 5, 1, ..., 2, 4, 12]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 144 / 10000 (1.44%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 3, 4, 5, ..., 6, 7, 2],
E [ 7, 5, 1, ..., 5, 5, 1],
E [ 4, 2, 3, ..., 11, 7, 3],...
E y: array([[ 3, 4, 5, ..., 6, 7, 2],
E [ 7, 5, 1, ..., 5, 5, 1],
E [ 4, 2, 3, ..., 11, 7, 3],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a781970> parameter: {...': (2,), 'mode': 'mirror', 'offset': [-1.3, 1.3], 'order': 5, 'output': None, 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 2, 4, 6, ..., 6, 7, 2],
[ 7, 5, 1, ..., 4, 5, 0],
[ 5, 2, 3, ..., 11, 7, 3],
... 2, 6, 4, ..., 1, 7, 7],
[ 4, 5, 8, ..., 3, 1, 2],
[ 9, 5, 1, ..., 2, 4, 12]], dtype=uint8)
desired = array([[ 2, 4, 6, ..., 6, 7, 2],
[ 7, 5, 1, ..., 4, 5, 0],
[ 5, 2, 3, ..., 11, 7, 3],
... 2, 6, 4, ..., 1, 7, 7],
[ 4, 5, 8, ..., 3, 1, 2],
[ 9, 5, 1, ..., 2, 4, 12]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 164 / 10000 (1.64%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 2, 4, 6, ..., 6, 7, 2],
E [ 7, 5, 1, ..., 4, 5, 0],
E [ 5, 2, 3, ..., 11, 7, 3],...
E y: array([[ 2, 4, 6, ..., 6, 7, 2],
E [ 7, 5, 1, ..., 4, 5, 0],
E [ 5, 2, 3, ..., 11, 7, 3],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a8f57c0> parameter: {...(2,), 'mode': 'mirror', 'offset': [-1.3, 1.3], 'order': 5, 'output': 'empty', 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 2, 4, 6, ..., 6, 7, 2],
[ 7, 5, 1, ..., 4, 5, 0],
[ 5, 2, 3, ..., 11, 7, 3],
... 2, 6, 4, ..., 1, 7, 7],
[ 4, 5, 8, ..., 3, 1, 2],
[ 9, 5, 1, ..., 2, 4, 12]], dtype=uint8)
desired = array([[ 2, 4, 6, ..., 6, 7, 2],
[ 7, 5, 1, ..., 4, 5, 0],
[ 5, 2, 3, ..., 11, 7, 3],
... 2, 6, 4, ..., 1, 7, 7],
[ 4, 5, 8, ..., 3, 1, 2],
[ 9, 5, 1, ..., 2, 4, 12]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 164 / 10000 (1.64%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 2, 4, 6, ..., 6, 7, 2],
E [ 7, 5, 1, ..., 4, 5, 0],
E [ 5, 2, 3, ..., 11, 7, 3],...
E y: array([[ 2, 4, 6, ..., 6, 7, 2],
E [ 7, 5, 1, ..., 4, 5, 0],
E [ 5, 2, 3, ..., 11, 7, 3],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a932a60> parameter: {...trix_shape': (2,), 'mode': 'wrap', 'offset': 0.3, 'order': 2, 'output': None, 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 5, 8, 0, ..., 3, 2, 5],
[ 2, 0, 6, ..., 2, 5, 2],
[ 4, 255, 0, ..., ..., 1, 4, 3],
[ 2, 5, 0, ..., 8, 2, 2],
[ 5, 8, 0, ..., 3, 2, 5]], dtype=uint8)
desired = array([[5, 8, 0, ..., 3, 2, 5],
[2, 0, 6, ..., 2, 5, 2],
[4, 0, 0, ..., 4, 7, 4],
...,
[3, 2, 3, ..., 1, 4, 3],
[2, 5, 0, ..., 8, 2, 2],
[5, 8, 0, ..., 3, 2, 5]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 88 / 10000 (0.88%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 5, 8, 0, ..., 3, 2, 5],
E [ 2, 0, 6, ..., 2, 5, 2],
E [ 4, 255, 0, ..., 4, 7, 4],...
E y: array([[5, 8, 0, ..., 3, 2, 5],
E [2, 0, 6, ..., 2, 5, 2],
E [4, 0, 0, ..., 4, 7, 4],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a79dc70> parameter: {...x_shape': (2,), 'mode': 'wrap', 'offset': 0.3, 'order': 2, 'output': 'empty', 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 5, 8, 0, ..., 3, 2, 5],
[ 2, 0, 6, ..., 2, 5, 2],
[ 4, 255, 0, ..., ..., 1, 4, 3],
[ 2, 5, 0, ..., 8, 2, 2],
[ 5, 8, 0, ..., 3, 2, 5]], dtype=uint8)
desired = array([[5, 8, 0, ..., 3, 2, 5],
[2, 0, 6, ..., 2, 5, 2],
[4, 0, 0, ..., 4, 7, 4],
...,
[3, 2, 3, ..., 1, 4, 3],
[2, 5, 0, ..., 8, 2, 2],
[5, 8, 0, ..., 3, 2, 5]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 88 / 10000 (0.88%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 5, 8, 0, ..., 3, 2, 5],
E [ 2, 0, 6, ..., 2, 5, 2],
E [ 4, 255, 0, ..., 4, 7, 4],...
E y: array([[5, 8, 0, ..., 3, 2, 5],
E [2, 0, 6, ..., 2, 5, 2],
E [4, 0, 0, ..., 4, 7, 4],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9ca796e6a0> parameter: {...trix_shape': (2,), 'mode': 'wrap', 'offset': 0.3, 'order': 3, 'output': None, 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 5, 8, 1, ..., 3, 2, 5],
[ 2, 0, 6, ..., 3, 6, 2],
[ 3, 255, 0, ..., ..., 1, 4, 3],
[ 2, 5, 0, ..., 7, 2, 2],
[ 5, 8, 1, ..., 3, 2, 5]], dtype=uint8)
desired = array([[5, 8, 1, ..., 3, 2, 5],
[2, 0, 6, ..., 3, 6, 2],
[3, 0, 0, ..., 4, 7, 3],
...,
[3, 2, 3, ..., 1, 4, 3],
[2, 5, 0, ..., 7, 2, 2],
[5, 8, 1, ..., 3, 2, 5]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 112 / 10000 (1.12%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 5, 8, 1, ..., 3, 2, 5],
E [ 2, 0, 6, ..., 3, 6, 2],
E [ 3, 255, 0, ..., 4, 7, 3],...
E y: array([[5, 8, 1, ..., 3, 2, 5],
E [2, 0, 6, ..., 3, 6, 2],
E [3, 0, 0, ..., 4, 7, 3],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9aa5f9a0> parameter: {...x_shape': (2,), 'mode': 'wrap', 'offset': 0.3, 'order': 3, 'output': 'empty', 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 5, 8, 1, ..., 3, 2, 5],
[ 2, 0, 6, ..., 3, 6, 2],
[ 3, 255, 0, ..., ..., 1, 4, 3],
[ 2, 5, 0, ..., 7, 2, 2],
[ 5, 8, 1, ..., 3, 2, 5]], dtype=uint8)
desired = array([[5, 8, 1, ..., 3, 2, 5],
[2, 0, 6, ..., 3, 6, 2],
[3, 0, 0, ..., 4, 7, 3],
...,
[3, 2, 3, ..., 1, 4, 3],
[2, 5, 0, ..., 7, 2, 2],
[5, 8, 1, ..., 3, 2, 5]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 112 / 10000 (1.12%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 5, 8, 1, ..., 3, 2, 5],
E [ 2, 0, 6, ..., 3, 6, 2],
E [ 3, 255, 0, ..., 4, 7, 3],...
E y: array([[5, 8, 1, ..., 3, 2, 5],
E [2, 0, 6, ..., 3, 6, 2],
E [3, 0, 0, ..., 4, 7, 3],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a6f81f0> parameter: {...trix_shape': (2,), 'mode': 'wrap', 'offset': 0.3, 'order': 4, 'output': None, 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 5, 8, 0, ..., 4, 2, 5],
[ 2, 0, 6, ..., 3, 6, 2],
[ 3, 255, 0, ..., ..., 0, 4, 3],
[ 2, 5, 255, ..., 7, 2, 2],
[ 5, 8, 0, ..., 4, 2, 5]], dtype=uint8)
desired = array([[5, 8, 0, ..., 4, 2, 5],
[2, 0, 6, ..., 3, 6, 2],
[3, 0, 0, ..., 4, 7, 3],
...,
[3, 2, 3, ..., 0, 4, 3],
[2, 5, 0, ..., 7, 2, 2],
[5, 8, 0, ..., 4, 2, 5]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 181 / 10000 (1.81%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 5, 8, 0, ..., 4, 2, 5],
E [ 2, 0, 6, ..., 3, 6, 2],
E [ 3, 255, 0, ..., 4, 7, 3],...
E y: array([[5, 8, 0, ..., 4, 2, 5],
E [2, 0, 6, ..., 3, 6, 2],
E [3, 0, 0, ..., 4, 7, 3],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9ce5e4e430> parameter: {...x_shape': (2,), 'mode': 'wrap', 'offset': 0.3, 'order': 4, 'output': 'empty', 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 5, 8, 0, ..., 4, 2, 5],
[ 2, 0, 6, ..., 3, 6, 2],
[ 3, 255, 0, ..., ..., 0, 4, 3],
[ 2, 5, 255, ..., 7, 2, 2],
[ 5, 8, 0, ..., 4, 2, 5]], dtype=uint8)
desired = array([[5, 8, 0, ..., 4, 2, 5],
[2, 0, 6, ..., 3, 6, 2],
[3, 0, 0, ..., 4, 7, 3],
...,
[3, 2, 3, ..., 0, 4, 3],
[2, 5, 0, ..., 7, 2, 2],
[5, 8, 0, ..., 4, 2, 5]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 181 / 10000 (1.81%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 5, 8, 0, ..., 4, 2, 5],
E [ 2, 0, 6, ..., 3, 6, 2],
E [ 3, 255, 0, ..., 4, 7, 3],...
E y: array([[5, 8, 0, ..., 4, 2, 5],
E [2, 0, 6, ..., 3, 6, 2],
E [3, 0, 0, ..., 4, 7, 3],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestAffineTransform object at 0x7f9c9a706b50> parameter: {...trix_shape': (2,), 'mode': 'wrap', 'offset': 0.3, 'order': 5, 'output': None, 'output_shape': None, 'prefilter': True}>
args = (), kw = {'dtype': <class 'numpy.uint8'>}, dtype = <class 'numpy.uint8'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 5, 9, 0, ..., 4, 2, 5],
[ 2, 0, 6, ..., 3, 6, 2],
[ 3, 255, 0, ..., ..., 0, 4, 3],
[ 2, 5, 255, ..., 7, 2, 2],
[ 5, 9, 0, ..., 4, 2, 5]], dtype=uint8)
desired = array([[5, 9, 0, ..., 4, 2, 5],
[2, 0, 6, ..., 3, 6, 2],
[3, 0, 0, ..., 4, 7, 3],
...,
[3, 2, 2, ..., 0, 4, 3],
[2, 5, 0, ..., 7, 2, 2],
[5, 9, 0, ..., 4, 2, 5]], dtype=uint8)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 210 / 10000 (2.1%)
E Max absolute difference: 255
E Max relative difference: 0.
E x: array([[ 5, 9, 0, ..., 4, 2, 5],
E [ 2, 0, 6, ..., 3, 6, 2],
E [ 3, 255, 0, ..., 4, 7, 3],...
E y: array([[5, 9, 0, ..., 4, 2, 5],
E [2, 0, 6, ..., 3, 6, 2],
E [3, 0, 0, ..., 4, 7, 3],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.uint8'>